Sink
Related Docs:
class Sink
| package javadsl
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 stage 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)
message 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 Subscribers and
the size of the inputBuffer configured for this stage 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 Subscribers.
A Sink that immediately cancels its upstream after materialization.
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 java.util.concurrent.CompletionStage will be completed with value of the final
function evaluation when the input stream ends, or completed with Failure
if there is a failure is 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 java.util.concurrent.CompletionStage will be completed with value of the final
function evaluation when the input stream ends, or completed with Failure
if there is a failure is 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 java.util.concurrent.CompletionStage will be completed with Success when reaching the
normal end of the stream, or completed with Failure if there is a failure is signaled in
the stream..
A Sink that will invoke the given procedure for each received element in parallel.
A Sink that will invoke the given procedure for each received element in parallel. The sink is materialized
into a java.util.concurrent.CompletionStage.
If f throws an exception and the supervision decision is
akka.stream.Supervision.Stop the CompletionStage 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.
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 CompletionStage of the first value received.
A Sink that materializes into a CompletionStage of the first value received.
If the stream completes before signaling at least a single element, the CompletionStage will be failed with a NoSuchElementException.
If the stream signals an error before signaling at least a single element, the CompletionStage will be failed with the streams exception.
See also headOption.
A Sink that materializes into a CompletionStage of the optional first value received.
A Sink that materializes into a CompletionStage of the optional first value received.
If the stream completes before signaling at least a single element, the value of the CompletionStage will be an empty java.util.Optional.
If the stream signals an error errors before signaling at least a single element, the CompletionStage 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 CompletionStage of the last value received.
A Sink that materializes into a CompletionStage of the last value received.
If the stream completes before signaling at least a single element, the CompletionStage will be failed with a NoSuchElementException.
If the stream signals an error errors before signaling at least a single element, the CompletionStage will be failed with the streams exception.
See also lastOption.
A Sink that materializes into a CompletionStage of the optional last value received.
A Sink that materializes into a CompletionStage of the optional last value received.
If the stream completes before signaling at least a single element, the value of the CompletionStage will be an empty java.util.Optional.
If the stream signals an error errors before signaling at least a single element, the CompletionStage will be failed with the streams exception.
See also head.
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 sinkFactory throws an exception and the supervision decision is
akka.stream.Supervision.Stop the Future will be completed with failure. For all other supervision options it will
try to create sink with next element
fallback will be executed when there was no elements and completed is received from upstream.
Adheres to the ActorAttributes.SupervisionStrategy attribute.
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.javadsl.SinkQueue.
Creates a Sink that is materialized as an akka.stream.javadsl.SinkQueue.
akka.stream.javadsl.SinkQueue.pull method is pulling element from the stream and returns CompletionStage[Option[T]]CompletionStage completes when element is available.
Before calling pull method second time you need to wait until previous CompletionStage 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.javadsl.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 java.util.concurrent.CompletionStage 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 stage will fail its downstream with a NoSuchElementException, which is semantically in-line with that Scala's standard library collections do in such situations.
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 CompletionStage of Seq[T] containing all the collected elements.
List is limited to Integer.MAX_VALUE 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
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 should
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.
(Since version ) see corresponding Javadoc for more information.
Java API