Flow

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def create[T](): Flow[T, T, NotUsed]

Create a Flow which can process elements of type T.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fromFunction[I, O](f: Function[I, O]): Flow[I, O, 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.create[T].map(f)
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.
def fromProcessor[I, O](processorFactory: Creator[Processor[I, O]]): Flow[I, O, NotUsed]
def fromProcessorMat[I, O, Mat](processorFactory: Creator[Pair[Processor[I, O], Mat]]): Flow[I, O, Mat]
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.

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 stages.

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.

def fromSinkAndSourceCoupledMat[I, O, M1, M2, M](sink: Graph[SinkShape[I], M1], source: Graph[SourceShape[O], M2], combine: Function2[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 stages.
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.
def fromSinkAndSourceMat[I, O, M1, M2, M](sink: Graph[SinkShape[I], M1], source: Graph[SourceShape[O], M2], combine: Function2[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.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def of[T](clazz: Class[T]): Flow[T, T, NotUsed]

Create a Flow which can process elements of type T.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: class Flow | package javadsl

object Flow

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def create[T](): Flow[T, T, NotUsed]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fromFunction[I, O](f: Function[I, O]): Flow[I, O, NotUsed]

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

def fromProcessor[I, O](processorFactory: Creator[Processor[I, O]]): Flow[I, O, NotUsed]

def fromProcessorMat[I, O, Mat](processorFactory: Creator[Pair[Processor[I, O], Mat]]): Flow[I, O, Mat]

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

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

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

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

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def of[T](clazz: Class[T]): Flow[T, T, NotUsed]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Deprecated Value Members

def finalize(): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped