Packages

object Flow

Source
Flow.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Flow
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def apply[T]: Flow[T, T, NotUsed]

    Returns a Flow which outputs all its inputs.

  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. def fromFunction[A, B](f: (A) ⇒ B): Flow[A, B, NotUsed]

    Creates a [Flow] which will use the given function to transform its inputs to outputs.

    Creates a [Flow] which will use the given function to transform its inputs to outputs. It is equivalent to Flow[T].map(f)

  11. def fromGraph[I, O, M](g: Graph[FlowShape[I, O], M]): Flow[I, O, M]

    A graph with the shape of a flow logically is a flow, this method makes it so also in type.

  12. def fromProcessor[I, O](processorFactory: () ⇒ Processor[I, O]): Flow[I, O, NotUsed]

    Creates a Flow from a Reactive Streams org.reactivestreams.Processor

  13. def fromProcessorMat[I, O, M](processorFactory: () ⇒ (Processor[I, O], M)): Flow[I, O, M]

    Creates a Flow from a Reactive Streams org.reactivestreams.Processor and returns a materialized value.

  14. def fromSinkAndSource[I, O](sink: Graph[SinkShape[I], _], source: Graph[SourceShape[O], _]): Flow[I, O, NotUsed]

    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.

    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 fromSinkAndSourceMat when access to materialized values of the parameters is needed.

  15. def fromSinkAndSourceCoupled[I, O](sink: Graph[SinkShape[I], _], source: Graph[SourceShape[O], _]): Flow[I, O, NotUsed]

    Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.

    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 fromSinkAndSourceCoupledMat when access to materialized values of the parameters is needed.

  16. def fromSinkAndSourceCoupledMat[I, O, M1, M2, M](sink: Graph[SinkShape[I], M1], source: Graph[SourceShape[O], M2])(combine: (M1, M2) ⇒ M): Flow[I, O, M]

    Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.

    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.

  17. def fromSinkAndSourceMat[I, O, M1, M2, M](sink: Graph[SinkShape[I], M1], source: Graph[SourceShape[O], M2])(combine: (M1, M2) ⇒ M): Flow[I, O, M]

    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.

    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.

  18. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  19. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  20. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  21. def lazyInitAsync[I, O, M](flowFactory: () ⇒ Future[Flow[I, O, M]]): Flow[I, O, Future[Option[M]]]

    Creates a real Flow upon receiving the first element.

    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

  22. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  24. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  25. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  26. def toString(): String
    Definition Classes
    AnyRef → Any
  27. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  28. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  29. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Deprecated Value Members

  1. def lazyInit[I, O, M](flowFactory: (I) ⇒ Future[Flow[I, O, M]], fallback: () ⇒ M): Flow[I, O, M]

    Creates a real Flow upon receiving the first element.

    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

    Annotations
    @Deprecated @deprecated
    Deprecated

    (Since version 2.5.12) Use lazyInitAsync instead. (lazyInitAsync returns a flow with a more useful materialized value.)

Inherited from AnyRef

Inherited from Any

Ungrouped