Actor

Type Members

implicit final class BehaviorDecorators[T] extends AnyVal
final class Immutable[T] extends ImmutableBehavior[T]
abstract class MutableBehavior[T] extends ExtensibleBehavior[T]

Mutable behavior can be implemented by extending this class and implement the abstract method MutableBehavior#onMessage and optionally override MutableBehavior#onSignal.
Mutable behavior can be implemented by extending this class and implement the abstract method MutableBehavior#onMessage and optionally override MutableBehavior#onSignal.
Instances of this behavior should be created via Actor#Mutable and if the ActorContext is needed it can be passed as a constructor parameter from the factory function.

See also
Actor#Mutable
final class Supervise[T] extends AnyVal

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
@throws( ... )
def deferred[T](factory: (ActorContext[T]) ⇒ Behavior[T]): Behavior[T]

deferred is a factory for a behavior.
deferred is a factory for a behavior. Creation of the behavior instance is deferred until the actor is started, as opposed to Actor.immutable that creates the behavior instance immediately before the actor is running. The factory function pass the ActorContext as parameter and that can for example be used for spawning child actors.
deferred is typically used as the outer most behavior when spawning an actor, but it can also be returned as the next behavior when processing a message or signal. In that case it will be "undeferred" immediately after it is returned, i.e. next message will be processed by the undeferred behavior.
def empty[T]: Behavior[T]

A behavior that treats every incoming message as unhandled.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def ignore[T]: Behavior[T]

A behavior that ignores every incoming message and returns “same”.
def immutable[T](onMessage: (ActorContext[T], T) ⇒ Behavior[T]): Immutable[T]

Construct an actor behavior that can react to both incoming messages and lifecycle signals.
Construct an actor behavior that can react to both incoming messages and lifecycle signals. After spawning this actor from another actor (or as the guardian of an akka.typed.ActorSystem) it will be executed within an ActorContext that allows access to the system, spawning and watching other actors, etc.
This constructor is called immutable because the behavior instance does not need and in fact should not use (close over) mutable variables, but instead return a potentially different behavior encapsulating any state changes.
def immutablePartial[T](onMessage: PartialFunction[(ActorContext[T], T), Behavior[T]]): Immutable[T]

Construct an immutable actor behavior from a partial message handler which treats undefined messages as unhandled.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def monitor[T](monitor: ActorRef[T], behavior: Behavior[T]): Behavior[T]

Behavior decorator that copies all received message to the designated monitor akka.typed.ActorRef before invoking the wrapped behavior.
Behavior decorator that copies all received message to the designated monitor akka.typed.ActorRef before invoking the wrapped behavior. The wrapped behavior can evolve (i.e. return different behavior) without needing to be wrapped in a monitor call again.
def mutable[T](factory: (ActorContext[T]) ⇒ MutableBehavior[T]): Behavior[T]

Factory for creating a MutableBehavior that typically holds mutable state as instance variables in the concrete MutableBehavior implementation class.
Factory for creating a MutableBehavior that typically holds mutable state as instance variables in the concrete MutableBehavior implementation class.
Creation of the behavior instance is deferred, i.e. it is created via the factory function. The reason for the deferred creation is to avoid sharing the same instance in multiple actors, and to create a new instance when the actor is restarted.
returns
the deferred behavior
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onSignal[T](handler: PartialFunction[(ActorContext[T], Signal), Behavior[T]]): Behavior[T]

Construct an actor behavior that can react to lifecycle signals only.
def same[T]: Behavior[T]

Return this behavior from message processing in order to advise the system to reuse the previous behavior.
Return this behavior from message processing in order to advise the system to reuse the previous behavior. This is provided in order to avoid the allocation overhead of recreating the current behavior where that is not necessary.
def stopped[T](postStop: Behavior[T]): Behavior[T]

Return this behavior from message processing to signal that this actor shall terminate voluntarily.
Return this behavior from message processing to signal that this actor shall terminate voluntarily. If this actor has created child actors then these will be stopped as part of the shutdown procedure.
The PostStop signal that results from stopping this actor will be passed to the given postStop behavior. All other messages and signals will effectively be ignored.
def stopped[T]: Behavior[T]

Return this behavior from message processing to signal that this actor shall terminate voluntarily.
Return this behavior from message processing to signal that this actor shall terminate voluntarily. If this actor has created child actors then these will be stopped as part of the shutdown procedure.
The PostStop signal that results from stopping this actor will be passed to the current behavior. All other messages and signals will effectively be ignored.
def supervise[T](wrapped: Behavior[T]): Supervise[T]

Wrap the given behavior such that it is restarted (i.e.
Wrap the given behavior such that it is restarted (i.e. reset to its initial state) whenever it throws an exception of the given class or a subclass thereof. Exceptions that are not subtypes of Thr will not be caught and thus lead to the termination of the actor.
It is possible to specify different supervisor strategies, such as restart, resume, backoff.
Note that only scala.util.control.NonFatal throwables will trigger the supervision strategy.
Example:
```
val dbConnector: Behavior[DbCommand] = ...

val dbRestarts =
   Actor.supervise(dbConnector)
     .onFailure(SupervisorStrategy.restart) // handle all NonFatal exceptions

val dbSpecificResumes =
   Actor.supervise(dbConnector)
     .onFailure[IndexOutOfBoundsException](SupervisorStrategy.resume) // resume for IndexOutOfBoundsException exceptions
```
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tap[T](onMessage: Function2[ActorContext[T], T, _], onSignal: Function2[ActorContext[T], Signal, _], behavior: Behavior[T]): Behavior[T]

This type of Behavior wraps another Behavior while allowing you to perform some action upon each received message or signal.
This type of Behavior wraps another Behavior while allowing you to perform some action upon each received message or signal. It is most commonly used for logging or tracing what a certain Actor does.
def toString(): String

Definition Classes
AnyRef → Any
def unhandled[T]: Behavior[T]

Return this behavior from message processing in order to advise the system to reuse the previous behavior, including the hint that the message has not been handled.
Return this behavior from message processing in order to advise the system to reuse the previous behavior, including the hint that the message has not been handled. This hint may be used by composite behaviors that delegate (partial) handling to other behaviors.
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( ... )
def withTimers[T](factory: (TimerScheduler[T]) ⇒ Behavior[T]): Behavior[T]

Support for scheduled self messages in an actor.
Support for scheduled self messages in an actor. It takes care of the lifecycle of the timers such as cancelling them when the actor is restarted or stopped.

See also
TimerScheduler

Related Doc: package scaladsl

object Actor

Type Members

implicit final class BehaviorDecorators[T] extends AnyVal

final class Immutable[T] extends ImmutableBehavior[T]

abstract class MutableBehavior[T] extends ExtensibleBehavior[T]

final class Supervise[T] extends AnyVal

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def deferred[T](factory: (ActorContext[T]) ⇒ Behavior[T]): Behavior[T]

def empty[T]: Behavior[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def ignore[T]: Behavior[T]

def immutable[T](onMessage: (ActorContext[T], T) ⇒ Behavior[T]): Immutable[T]

def immutablePartial[T](onMessage: PartialFunction[(ActorContext[T], T), Behavior[T]]): Immutable[T]

final def isInstanceOf[T0]: Boolean

def monitor[T](monitor: ActorRef[T], behavior: Behavior[T]): Behavior[T]

def mutable[T](factory: (ActorContext[T]) ⇒ MutableBehavior[T]): Behavior[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onSignal[T](handler: PartialFunction[(ActorContext[T], Signal), Behavior[T]]): Behavior[T]

def same[T]: Behavior[T]

def stopped[T](postStop: Behavior[T]): Behavior[T]

def stopped[T]: Behavior[T]

def supervise[T](wrapped: Behavior[T]): Supervise[T]

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

def tap[T](onMessage: Function2[ActorContext[T], T, _], onSignal: Function2[ActorContext[T], Signal, _], behavior: Behavior[T]): Behavior[T]

def toString(): String

def unhandled[T]: Behavior[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withTimers[T](factory: (TimerScheduler[T]) ⇒ Behavior[T]): Behavior[T]

Inherited from AnyRef

Inherited from Any

Ungrouped