Class Balance<T>

  • All Implemented Interfaces:
    Graph<UniformFanOutShape<T,​T>,​NotUsed>

    public final class Balance<T>
    extends GraphStage<UniformFanOutShape<T,​T>>
    Fan-out the stream to several streams. Each upstream element is emitted to the first available downstream consumer. It will not shut down until the subscriptions for at least two downstream subscribers have been established.

    A Balance has one in port and 2 or more out ports.

    '''Emits when''' any of the outputs stops backpressuring; emits the element to the first available output

    '''Backpressures when''' all of the outputs backpressure

    '''Completes when''' upstream completes

    '''Cancels when''' If eagerCancel is enabled: when any downstream cancels; otherwise: when all downstreams cancel

    • Constructor Detail

      • Balance

        public Balance​(int outputPorts,
                       boolean waitForAllDownstreams,
                       boolean eagerCancel)
      • Balance

        public Balance​(int outputPorts,
                       boolean waitForAllDownstreams)
        Deprecated.
        Use the constructor which also specifies the `eagerCancel` parameter. Since 2.5.12.
    • Method Detail

      • apply

        public static <T> Balance<T> apply​(int outputPorts,
                                           boolean waitForAllDownstreams)
        Create a new Balance with the specified number of output ports. This method sets eagerCancel to false. To specify a different value for the eagerCancel parameter, then instantiate Balance using the constructor.

        If eagerCancel is true, balance cancels upstream if any of its downstreams cancel, if false, when all have cancelled.

        Parameters:
        outputPorts - number of output ports
        waitForAllDownstreams - if you use waitForAllDownstreams = true it will not start emitting elements to downstream outputs until all of them have requested at least one element, default value is false
        Returns:
        (undocumented)
      • apply$default$2

        public static <T> boolean apply$default$2()
      • named

        public static Graph<S,​M> named​(java.lang.String name)
      • async

        public static Graph<S,​M> async()
      • async

        public static Graph<S,​M> async​(java.lang.String dispatcher)
      • async

        public static Graph<S,​M> async​(java.lang.String dispatcher,
                                             int inputBufferSize)
      • addAttributes

        public static Graph<S,​M> addAttributes​(Attributes attr)
      • withAttributes

        public static final Graph<S,​M> withAttributes​(Attributes attr)
      • createLogicAndMaterializedValue

        public static final scala.Tuple2<GraphStageLogic,​NotUsed> createLogicAndMaterializedValue​(Attributes inheritedAttributes)
      • outputPorts

        public int outputPorts()
      • waitForAllDownstreams

        public boolean waitForAllDownstreams()
      • eagerCancel

        public boolean eagerCancel()
      • out

        public scala.collection.immutable.IndexedSeq<Outlet<T>> out()
      • shape

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

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