Package org.apache.pekko.stream.javadsl

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

java.lang.Object
org.apache.pekko.stream.javadsl.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 Object implements Graph<BidiShape<I1,O1,I2,O2>,Mat>

  • Constructor Details

  • Method Details

    • 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(Duration timeout)
      If the time between two processed elements *in any direction* exceed the provided timeout, the stream is failed with a BackpressureTimeoutException.

      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 org.apache.pekko.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>

    • asScala

      public BidiFlow<I1,O1,I2,O2,Mat> asScala()

    • 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(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()
      Put an asynchronous boundary around this Flow
      Specified by:
      async in interface Graph<I1,O1>

    • async

      public BidiFlow<I1,O1,I2,O2,Mat> async(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(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

    • getAttributes

      public Attributes getAttributes()
      Specified by:
      getAttributes in interface Graph<I1,O1>