Package akka.stream.javadsl

Class BidiFlow<I1,​O1,​I2,​O2,​Mat>

  • All Implemented Interfaces:
    Graph<BidiShape<I1,​O1,​I2,​O2>,​Mat>
    public final class BidiFlow<I1,​O1,​I2,​O2,​Mat>
extends java.lang.Object
implements Graph<BidiShape<I1,​O1,​I2,​O2>,​Mat>

    • Method Detail

      • identity

        public static <A,​B> BidiFlow<A,​A,​B,​B,​NotUsed> identity()

      • fromGraph

        public static <I1,​O1,​I2,​O2,​M> BidiFlow<I1,​O1,​I2,​O2,​M> fromGraph​(Graph<BidiShape<I1,​O1,​I2,​O2>,​M> g)
        A graph with the shape of a BidiFlow logically is a BidiFlow, this method makes it so also in type.

      • fromFlowsMat

        public static <I1,​O1,​I2,​O2,​M1,​M2,​M> BidiFlow<I1,​O1,​I2,​O2,​M> fromFlowsMat​(Graph<FlowShape<I1,​O1>,​M1> flow1,
                                                                                                                                     Graph<FlowShape<I2,​O2>,​M2> flow2,
                                                                                                                                     Function2<M1,​M2,​M> combine)
        Wraps two Flows to create a ''BidiFlow''. The materialized value of the resulting BidiFlow is determined by the combiner function passed in the second argument list. 

        
     +----------------------------+
     | Resulting BidiFlow         |
     |                            |
     |  +----------------------+  |
 I1 ~~> |        Flow1         | ~~> O1
     |  +----------------------+  |
     |                            |
     |  +----------------------+  |
 O2 <~~ |        Flow2         | <~~ I2
     |  +----------------------+  |
     +----------------------------+

      • fromFlows

        public static <I1,​O1,​I2,​O2,​M1,​M2> BidiFlow<I1,​O1,​I2,​O2,​NotUsed> fromFlows​(Graph<FlowShape<I1,​O1>,​M1> flow1,
                                                                                                                                Graph<FlowShape<I2,​O2>,​M2> flow2)
        Wraps two Flows to create a ''BidiFlow''. The materialized value of the resulting BidiFlow is NotUsed. 

        
     +----------------------------+
     | Resulting BidiFlow         |
     |                            |
     |  +----------------------+  |
 I1 ~~> |        Flow1         | ~~> O1
     |  +----------------------+  |
     |                            |
     |  +----------------------+  |
 O2 <~~ |        Flow2         | <~~ I2
     |  +----------------------+  |
     +----------------------------+

      • fromFunctions

        public static <I1,​O1,​I2,​O2> BidiFlow<I1,​O1,​I2,​O2,​NotUsed> fromFunctions​(Function<I1,​O1> top,
                                                                                                                  Function<I2,​O2> bottom)
        Create a BidiFlow where the top and bottom flows are just one simple mapping operator each, expressed by the two functions.

      • bidirectionalIdleTimeout

        public static <I,​O> BidiFlow<I,​I,​O,​O,​NotUsed> bidirectionalIdleTimeout​(java.time.Duration timeout)
        If the time between two processed elements *in any direction* exceed the provided timeout, the stream is failed with a StreamIdleTimeoutException.

        There is a difference between this operator and having two idleTimeout Flows assembled into a BidiStage. If the timeout is configured to be 1 seconds, then this operator will not fail even though there are elements flowing every second in one direction, but no elements are flowing in the other direction. I.e. this operator considers the *joint* frequencies of the elements in both directions.

      • traversalBuilder

        public akka.stream.impl.TraversalBuilder 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<I1,​O1>

      • shape

        public BidiShape<I1,​O1,​I2,​O2> 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<I1,​O1>

      • atop

        public <OO1,​II2,​Mat2> BidiFlow<I1,​OO1,​II2,​O2,​Mat> atop​(BidiFlow<O1,​OO1,​II2,​I2,​Mat2> bidi)
        Add the given BidiFlow as the next step in a bidirectional transformation pipeline. By convention protocol stacks are growing to the left: the right most is the bottom layer, the closest to the metal. 
        
     +----------------------------+
     | Resulting BidiFlow         |
     |                            |
     |  +------+        +------+  |
 I1 ~~> |      |  ~O1~> |      | ~~> OO1
     |  | this |        | bidi |  |
 O2 <~~ |      | <~I2~  |      | <~~ II2
     |  +------+        +------+  |
     +----------------------------+
        The materialized value of the combined BidiFlow will be the materialized value of the current flow (ignoring the other BidiFlow&rsquo;s value), use atopMat if a different strategy is needed.

      • atop

        public <OO1,​II2,​Mat2,​M> BidiFlow<I1,​OO1,​II2,​O2,​M> atop​(BidiFlow<O1,​OO1,​II2,​I2,​Mat2> bidi,
                                                                                                 Function2<Mat,​Mat2,​M> combine)
        Add the given BidiFlow as the next step in a bidirectional transformation 161

        pipeline. By convention protocol stacks are growing to the left: the right most is the bottom layer, the closest to the metal. 

        
     +----------------------------+
     | Resulting BidiFlow         |
     |                            |
     |  +------+        +------+  |
 I1 ~~> |      |  ~O1~> |      | ~~> OO1
     |  | this |        | bidi |  |
 O2 <~~ |      | <~I2~  |      | <~~ II2
     |  +------+        +------+  |
     +----------------------------+
        The combine function is used to compose the materialized values of this flow and that flow into the materialized value of the resulting BidiFlow.

      • join

        public <Mat2> Flow<I1,​O2,​Mat> join​(Flow<O1,​I2,​Mat2> flow)
        Add the given Flow as the final step in a bidirectional transformation pipeline. By convention protocol stacks are growing to the left: the right most is the bottom layer, the closest to the metal. 
        
     +---------------------------+
     | Resulting Flow            |
     |                           |
     |  +------+        +------+ |
 I1 ~~> |      |  ~O1~> |      | |
     |  | this |        | flow | |
 O2 <~~ |      | <~I2~  |      | |
     |  +------+        +------+ |
     +---------------------------+
        The materialized value of the combined Flow will be the materialized value of the current flow (ignoring the other Flow&rsquo;s value), use joinMat if a different strategy is needed.

      • join

        public <Mat2,​M> Flow<I1,​O2,​M> join​(Flow<O1,​I2,​Mat2> flow,
                                                     Function2<Mat,​Mat2,​M> combine)
        Add the given Flow as the final step in a bidirectional transformation pipeline. By convention protocol stacks are growing to the left: the right most is the bottom layer, the closest to the metal. 
        
     +---------------------------+
     | Resulting Flow            |
     |                           |
     |  +------+        +------+ |
 I1 ~~> |      |  ~O1~> |      | |
     |  | this |        | flow | |
 O2 <~~ |      | <~I2~  |      | |
     |  +------+        +------+ |
     +---------------------------+
        The combine function is used to compose the materialized values of this flow and that flow into the materialized value of the resulting Flow.

      • reversed

        public BidiFlow<I2,​O2,​I1,​O1,​Mat> reversed()
        Turn this BidiFlow around by 180 degrees, logically flipping it upside down in a protocol stack.

      • mapMaterializedValue

        public <Mat2> BidiFlow<I1,​O1,​I2,​O2,​Mat2> mapMaterializedValue​(Function<Mat,​Mat2> f)
        Transform only the materialized value of this BidiFlow, leaving all other properties as they were.

      • withAttributes

        public BidiFlow<I1,​O1,​I2,​O2,​Mat> withAttributes​(Attributes attr)
        Change the attributes of this Source 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 operators).
        Specified by:
        withAttributes in interface Graph<I1,​O1>

      • addAttributes

        public BidiFlow<I1,​O1,​I2,​O2,​Mat> addAttributes​(Attributes attr)
        Add the given attributes to this Source. 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 operators).
        Specified by:
        addAttributes in interface Graph<I1,​O1>

      • named

        public BidiFlow<I1,​O1,​I2,​O2,​Mat> named​(java.lang.String name)
        Add a name attribute to this Flow.
        Specified by:
        named in interface Graph<I1,​O1>

      • async

        public BidiFlow<I1,​O1,​I2,​O2,​Mat> async​(java.lang.String dispatcher)
        Put an asynchronous boundary around this Flow

        Specified by:
        async in interface Graph<I1,​O1>
        Parameters:
        dispatcher - Run the graph on this dispatcher

      • async

        public BidiFlow<I1,​O1,​I2,​O2,​Mat> async​(java.lang.String dispatcher,
                                                               int inputBufferSize)
        Put an asynchronous boundary around this Flow

        Specified by:
        async in interface Graph<I1,​O1>
        Parameters:
        dispatcher - Run the graph on this dispatcher
        inputBufferSize - Set the input buffer to this size for the graph