Implement by handling incoming commands and return an Effect() to persist or signal other effects of the command handling such as stopping the behavior or others.

Use DurableStateBehavior#newCommandHandlerBuilder to define the command handlers.

The command handlers are only invoked when the actor is running (i.e. not recovering). While the actor is persisting state, the incoming messages are stashed and only delivered to the handler once persisting them has completed.

Implement by returning the initial empty state object. This object will be passed into this behaviors handlers, until a new state replaces it.

Also known as "zero state" or "neutral state".

Factory of effects.

Return effects from your handlers in order to instruct persistence on how to act on the incoming message (i.e. persist state).

INTERNAL API: DeferredBehavior init, not for user extension

API May Change: Override this and implement the ChangeEventHandler to store additional change event when the state is updated or deleted. The event can be used in Projections.

Narrow the type of this Behavior, which is always a safe operation. This method is necessary to implement the contravariant nature of Behavior (which cannot be expressed directly due to type inference problems).

Override to react on general lifecycle signals and DurableStateBehavior specific signals (recovery related). Those are all subtypes of akka.persistence.typed.state.DurableStateSignal.

Use DurableStateBehavior#newSignalHandlerBuilder to define the signal handler.

Transform the state into another type before giving it to and from the store. Can be used to migrate from different state types e.g. when migration from PersistentFSM to Typed DurableStateBehavior.

Override to define a custom stash capacity per entity. If not defined, the default akka.persistence.typed.stash-capacity will be used.

Transform the incoming messages by placing a funnel in front of the wrapped Behavior: the supplied PartialFunction decides which message to pull in (those that it is defined at) and may transform the incoming message to place them into the wrapped Behavior’s type hierarchy. Signals are not transformed.

Example:

val b: Behavior[Number] =
  Behaviors
    .receive[String] { (ctx, msg) =>
      println(msg)
      Behaviors.same
    }
    .transformMessages[Number] {
      case b: BigDecimal => s"BigDecimal($b)"
      case i: BigInt     => s"BigInteger($i)"
      // all other kinds of Number will be `unhandled`
    }

The ClassTag for Outer ensures that only messages of this class or a subclass thereof will be intercepted. Other message types (e.g. a private protocol) will bypass the interceptor and be continue to the inner behavior untouched.