object Flow
- Source
- Flow.scala
- Alphabetic
- By Inheritance
- Flow
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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
-
def
apply[T]: Flow[T, T, NotUsed]
Returns a
Flowwhich outputs all its inputs. -
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate() @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
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) -
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: () ⇒ Processor[I, O]): Flow[I, O, NotUsed]
Creates a Flow from a Reactive Streams org.reactivestreams.Processor
-
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.
-
def
fromSinkAndSource[I, O](sink: Graph[SinkShape[I], _], source: Graph[SourceShape[O], _]): Flow[I, O, NotUsed]
Creates a
Flowfrom aSinkand aSourcewhere the Flow's input will be sent to the Sink and the Flow's output will come from the Source.Creates a
Flowfrom aSinkand aSourcewhere 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.fromSinkAndSourceCoupledinstead.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 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.
-
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
combinefunction is used to compose the materialized values of thesinkandsourceinto 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: (M1, M2) ⇒ M): Flow[I, O, M]
Creates a
Flowfrom aSinkand aSourcewhere the Flow's input will be sent to the Sink and the Flow's output will come from the Source.Creates a
Flowfrom aSinkand aSourcewhere 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.fromSinkAndSourceCoupledMatinstead.The
combinefunction is used to compose the materialized values of thesinkandsourceinto the materialized value of the resulting Flow. -
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
lazyInitAsync[I, O, M](flowFactory: () ⇒ Future[Flow[I, O, M]]): Flow[I, O, Future[Option[M]]]
Creates a real
Flowupon receiving the first element.Creates a real
Flowupon receiving the first element. InternalFlowwill not be created if there are no elements, because of completion, cancellation, or error.The materialized value of the
Flowis aFuture[Option[M]]that is completed withSome(mat)when the internal flow gets materialized or withNonewhen there where no elements. If the flow materialization (including the call of theflowFactory) 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
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
setup[T, U, M](factory: (ActorMaterializer, Attributes) ⇒ Flow[T, U, M]): Flow[T, U, Future[M]]
Defers the creation of a Flow until materialization.
Defers the creation of a Flow until materialization. The
factoryfunction exposes ActorMaterializer which is going to be used during materialization and Attributes of the Flow returned by this method. -
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
wait(): 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.
-
def
lazyInit[I, O, M](flowFactory: (I) ⇒ Future[Flow[I, O, M]], fallback: () ⇒ M): Flow[I, O, M]
Creates a real
Flowupon receiving the first element.Creates a real
Flowupon receiving the first element. InternalFlowwill not be created if there are no elements, because of completion, cancellation, or error.The materialized value of the
Flowis the value that is created by thefallbackfunction.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.)