Sends the elements of the stream to the given ActorRef
.
Sends the elements of the stream to the given ActorRef
.
If the target actor terminates the stream will be canceled.
When the stream is completed successfully the given onCompleteMessage
will be sent to the destination actor.
When the stream is completed with failure a akka.actor.Status.Failure
message will be sent to the destination actor.
It will request at most maxInputBufferSize
number of elements from
upstream, but there is no back-pressure signal from the destination actor,
i.e. if the actor is not consuming the messages fast enough the mailbox
of the actor will grow. For potentially slow consumer actors it is recommended
to use a bounded mailbox with zero mailbox-push-timeout-time
or use a rate
limiting operator in front of this Sink
.
Sends the elements of the stream to the given ActorRef
that sends back back-pressure signal.
Sends the elements of the stream to the given ActorRef
that sends back back-pressure signal.
First element is always onInitMessage
, then stream is waiting for acknowledgement message
ackMessage
from the given actor which means that it is ready to process
elements. It also requires ackMessage
message after each stream element
to make backpressure work.
If the target actor terminates the stream will be canceled.
When the stream is completed successfully the given onCompleteMessage
will be sent to the destination actor.
When the stream is completed with failure - result of onFailureMessage(throwable)
function will be sent to the destination actor.
A Sink
that materializes into a org.reactivestreams.Publisher.
A Sink
that materializes into a org.reactivestreams.Publisher.
If fanout
is true
, the materialized Publisher
will support multiple Subscriber
s and
the size of the inputBuffer
configured for this operator becomes the maximum number of elements that
the fastest org.reactivestreams.Subscriber can be ahead of the slowest one before slowing
the processing down due to back pressure.
If fanout
is false
then the materialized Publisher
will only support a single Subscriber
and
reject any additional Subscriber
s.
A Sink
that immediately cancels its upstream after materialization.
A Sink
that keeps on collecting incoming elements until upstream terminates.
A Sink
that keeps on collecting incoming elements until upstream terminates.
As upstream may be unbounded, Flow[T].take
or the stricter Flow[T].limit
(and their variants)
may be used to ensure boundedness.
Materializes into a Future
of That[T]
containing all the collected elements.
That[T]
is limited to the limitations of the CanBuildFrom associated with it. For example, Seq
is limited to
Int.MaxValue
elements. See [The Architecture of Scala 2.13's Collections](https://docs.scala-lang.org/overviews/core/architecture-of-scala-213-collections.html) for more info.
This Sink will cancel the stream after having received that many elements.
See also Flow.limit, Flow.limitWeighted, Flow.take, Flow.takeWithin, Flow.takeWhile
Combine several sinks with fan-out strategy like Broadcast
or Balance
and returns Sink
.
A Sink
that will invoke the given function for every received element, giving it its previous
output (or the given zero
value) and the element as input.
A Sink
that will invoke the given function for every received element, giving it its previous
output (or the given zero
value) and the element as input.
The returned scala.concurrent.Future will be completed with value of the final
function evaluation when the input stream ends, or completed with Failure
if there is a failure signaled in the stream.
A Sink
that will invoke the given asynchronous function for every received element, giving it its previous
output (or the given zero
value) and the element as input.
A Sink
that will invoke the given asynchronous function for every received element, giving it its previous
output (or the given zero
value) and the element as input.
The returned scala.concurrent.Future will be completed with value of the final
function evaluation when the input stream ends, or completed with Failure
if there is a failure signaled in the stream.
A Sink
that will invoke the given procedure for each received element.
A Sink
that will invoke the given procedure for each received element. The sink is materialized
into a scala.concurrent.Future which will be completed with Success
when reaching the
normal end of the stream, or completed with Failure
if there is a failure signaled in
the stream.
A Sink
that will invoke the given procedure asynchronously for each received element.
A Sink
that will invoke the given procedure asynchronously for each received element. The sink is materialized
into a scala.concurrent.Future which will be completed with Success
when reaching the
normal end of the stream, or completed with Failure
if there is a failure signaled in
the stream.
A graph with the shape of a sink logically is a sink, this method makes it so also in type.
Helper to create Sink from Subscriber
.
A Sink
that materializes into a Future
of the first value received.
A Sink
that materializes into a Future
of the first value received.
If the stream completes before signaling at least a single element, the Future will be failed with a NoSuchElementException.
If the stream signals an error errors before signaling at least a single element, the Future will be failed with the streams exception.
See also headOption.
A Sink
that materializes into a Future
of the optional first value received.
A Sink
that materializes into a Future
of the optional first value received.
If the stream completes before signaling at least a single element, the value of the Future will be None.
If the stream signals an error errors before signaling at least a single element, the Future will be failed with the streams exception.
See also head.
A Sink
that will consume the stream and discard the elements.
A Sink
that materializes into a Future
of the last value received.
A Sink
that materializes into a Future
of the last value received.
If the stream completes before signaling at least a single element, the Future will be failed with a NoSuchElementException.
If the stream signals an error, the Future will be failed with the stream's exception.
See also lastOption, takeLast.
A Sink
that materializes into a Future
of the optional last value received.
Creates a real Sink
upon receiving the first element.
Creates a real Sink
upon receiving the first element. Internal Sink
will not be created if there are no elements,
because of completion or error.
If upstream completes before an element was received then the Future
is completed with None
.
If upstream fails before an element was received, sinkFactory
throws an exception, or materialization of the internal
sink fails then the Future
is completed with the exception.
Otherwise the Future
is completed with the materialized value of the internal sink.
A Sink
that when the flow is completed, either through a failure or normal
completion, apply the provided function with scala.util.Success
or scala.util.Failure.
Creates a Sink
that is materialized as an akka.stream.scaladsl.SinkQueue.
Creates a Sink
that is materialized as an akka.stream.scaladsl.SinkQueue.
akka.stream.scaladsl.SinkQueue.pull method is pulling element from the stream and returns
.
Future[Option[T]]
Future
completes when element is available.
Before calling pull method second time you need to wait until previous Future completes. Pull returns Failed future with IllegalStateException if previous future has not yet completed.
Sink
will request at most number of elements equal to size of inputBuffer
from
upstream and then stop back pressure. You can configure size of input
buffer by using Sink.withAttributes method.
For stream completion you need to pull all elements from akka.stream.scaladsl.SinkQueue including last None as completion marker
A Sink
that will invoke the given function for every received element, giving it its previous
output (from the second element) and the element as input.
A Sink
that will invoke the given function for every received element, giving it its previous
output (from the second element) and the element as input.
The returned scala.concurrent.Future will be completed with value of the final
function evaluation when the input stream ends, or completed with Failure
if there is a failure signaled in the stream.
If the stream is empty (i.e. completes before signalling any elements), the reduce operator will fail its downstream with a NoSuchElementException, which is semantically in-line with that Scala's standard library collections do in such situations.
Adheres to the ActorAttributes.SupervisionStrategy attribute.
A Sink
that keeps on collecting incoming elements until upstream terminates.
A Sink
that keeps on collecting incoming elements until upstream terminates.
As upstream may be unbounded, Flow[T].take
or the stricter Flow[T].limit
(and their variants)
may be used to ensure boundedness.
Materializes into a Future
of Seq[T]
containing all the collected elements.
Seq
is limited to Int.MaxValue
elements, this Sink will cancel the stream
after having received that many elements.
See also Flow.limit, Flow.limitWeighted, Flow.take, Flow.takeWithin, Flow.takeWhile
Defers the creation of a Sink until materialization.
Defers the creation of a Sink until materialization. The factory
function
exposes ActorMaterializer which is going to be used during materialization and
Attributes of the Sink returned by this method.
INTERNAL API
A Sink
that materializes into a a Future
of immutable.Seq[T]
containing the last n
collected elements.
A Sink
that materializes into a a Future
of immutable.Seq[T]
containing the last n
collected elements.
If the stream completes before signaling at least n elements, the Future
will complete with all elements seen so far.
If the stream never completes, the Future
will never complete.
If there is a failure signaled in the stream the Future
will be completed with failure.
Creates a Sink
that is materialized to an akka.actor.ActorRef which points to an Actor
created according to the passed in akka.actor.Props.
Creates a Sink
that is materialized to an akka.actor.ActorRef which points to an Actor
created according to the passed in akka.actor.Props. Actor created by the props
must
be akka.stream.actor.ActorSubscriber.
(Since version 2.5.0) Use akka.stream.stage.GraphStage
and fromGraph
instead, it allows for all operations an Actor would and is more type-safe as well as guaranteed to be ReactiveStreams compliant.
A Sink
that will invoke the given function to each of the elements
as they pass in.
A Sink
that will invoke the given function to each of the elements
as they pass in. The sink is materialized into a scala.concurrent.Future
If f
throws an exception and the supervision decision is
akka.stream.Supervision.Stop the Future
will be completed with failure.
If f
throws an exception and the supervision decision is
akka.stream.Supervision.Resume or akka.stream.Supervision.Restart the
element is dropped and the stream continues.
See also Flow.mapAsyncUnordered
(Since version 2.5.17) Use foreachAsync
instead, it allows you to choose how to run the procedure, by calling some other API returning a Future or spawning a new Future.
Creates a real Sink
upon receiving the first element.
Creates a real Sink
upon receiving the first element. Internal Sink
will not be created if there are no elements,
because of completion or error.
If upstream completes before an element was received then the Future
is completed with the value created by fallback.
If upstream fails before an element was received, sinkFactory
throws an exception, or materialization of the internal
sink fails then the Future
is completed with the exception.
Otherwise the Future
is completed with the materialized value of the internal sink.
(Since version 2.5.11) Use lazyInitAsync instead. (lazyInitAsync no more needs a fallback function and the materialized value more clearly indicates if the internal sink was materialized or not.)