Package akka.stream.typed.javadsl

Class ActorSource$

java.lang.Object

akka.stream.typed.javadsl.ActorSource$

public class ActorSource$
extends java.lang.Object

Collection of Sources aimed at integrating with typed Actors.

Field Summary

Fields

Modifier and Type	Field	Description
static ActorSource$	MODULE$	Static reference to the singleton instance of this Scala object.

Constructor Summary

Constructors

Constructor	Description
ActorSource$()

Method Summary

Modifier and Type	Method	Description
<T> Source<T,ActorRef<T>>	actorRef(java.util.function.Predicate<T> completionMatcher, Function<T,java.util.Optional<java.lang.Throwable>> failureMatcher, int bufferSize, OverflowStrategy overflowStrategy)	Creates a Source that is materialized as an ActorRef.
<T,Ack> Source<T,ActorRef<T>>	actorRefWithAck(ActorRef<Ack> ackTo, Ack ackMessage, Function<T,java.util.Optional<CompletionStrategy>> completionMatcher, Function<T,java.util.Optional<java.lang.Throwable>> failureMatcher)	Deprecated. Use actorRefWithBackpressure instead
<T,Ack> Source<T,ActorRef<T>>	actorRefWithBackpressure(ActorRef<Ack> ackTo, Ack ackMessage, Function<T,java.util.Optional<CompletionStrategy>> completionMatcher, Function<T,java.util.Optional<java.lang.Throwable>> failureMatcher)	Creates a Source that is materialized as an ActorRef.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

MODULE$

public static final ActorSource$ MODULE$

Static reference to the singleton instance of this Scala object.

Constructor Detail

ActorSource$

public ActorSource$()

Method Detail

actorRef

public <T> Source<T,ActorRef<T>> actorRef(java.util.function.Predicate<T> completionMatcher,
                                                Function<T,java.util.Optional<java.lang.Throwable>> failureMatcher,
                                                int bufferSize,
                                                OverflowStrategy overflowStrategy)

Creates a Source that is materialized as an ActorRef. Messages sent to this actor will be emitted to the stream if there is demand from downstream, otherwise they will be buffered until request for demand is received.

Depending on the defined OverflowStrategy it might drop elements if there is no space available in the buffer.

The strategy akka.stream.OverflowStrategy.backpressure is not supported, and an IllegalArgument("Backpressure overflowStrategy not supported") will be thrown if it is passed as argument.

The buffer can be disabled by using bufferSize of 0 and then received messages are dropped if there is no demand from downstream. When bufferSize is 0 the overflowStrategy does not matter.

The stream can be completed successfully by sending the actor reference a Status.Success (whose content will be ignored) in which case already buffered elements will be signaled before signaling completion, or by sending PoisonPill in which case completion will be signaled immediately.

The stream can be completed with failure by sending a Status.Failure to the actor reference. In case the Actor is still draining its internal buffer (after having received a Status.Success) before signaling completion and it receives a Status.Failure, the failure will be signaled downstream immediately (instead of the completion signal).

The actor will be stopped when the stream is completed, failed or canceled from downstream, i.e. you can watch it to get notified when that happens.

See also akka.stream.javadsl.Source.queue.

Parameters:

bufferSize - The size of the buffer in element count

overflowStrategy - Strategy that is used when incoming elements cannot fit inside the buffer

actorRefWithBackpressure

public <T,Ack> Source<T,ActorRef<T>> actorRefWithBackpressure(ActorRef<Ack> ackTo,
                                                                          Ack ackMessage,
                                                                          Function<T,java.util.Optional<CompletionStrategy>> completionMatcher,
                                                                          Function<T,java.util.Optional<java.lang.Throwable>> failureMatcher)

Creates a Source that is materialized as an ActorRef. Messages sent to this actor will be emitted to the stream if there is demand from downstream, and a new message will only be accepted after the previous messages has been consumed and acknowledged back. The stream will complete with failure if a message is sent before the acknowledgement has been replied back.

The stream can be completed by sending a message that is matched by completionMatcher which decides if the stream is to drained before completion or should complete immediately.

A message that is matched by failureMatcher fails the stream. The extracted Throwable will be used to fail the stream. In case the Actor is still draining its internal buffer (after having received a message matched by completionMatcher) before signaling completion and it receives a message matched by failureMatcher, the failure will be signaled downstream immediately (instead of the completion signal).

The actor will be stopped when the stream is completed, failed or canceled from downstream, i.e. you can watch it to get notified when that happens.

actorRefWithAck

public <T,Ack> Source<T,ActorRef<T>> actorRefWithAck(ActorRef<Ack> ackTo,
                                                                 Ack ackMessage,
                                                                 Function<T,java.util.Optional<CompletionStrategy>> completionMatcher,
                                                                 Function<T,java.util.Optional<java.lang.Throwable>> failureMatcher)

Deprecated.

Use actorRefWithBackpressure instead

Creates a Source that is materialized as an ActorRef. Messages sent to this actor will be emitted to the stream if there is demand from downstream, and a new message will only be accepted after the previous messages has been consumed and acknowledged back. The stream will complete with failure if a message is sent before the acknowledgement has been replied back.

The stream can be completed with failure by sending a message that is matched by failureMatcher. The extracted Throwable will be used to fail the stream. In case the Actor is still draining its internal buffer (after having received a message matched by completionMatcher) before signaling completion and it receives a message matched by failureMatcher, the failure will be signaled downstream immediately (instead of the completion signal).

The actor will be stopped when the stream is completed, failed or canceled from downstream, i.e. you can watch it to get notified when that happens.