Can be overridden to intercept calls to `PostRestart`. Calls `PostRestart` by default.

Can be overridden to intercept calls to `PostStop`. Calls `PostStop` by default..

Can be overridden to intercept calls to `PreRestart`. Calls `PreRestart` by default.

Can be overridden to intercept calls to `PreStart`. Calls `PreStart` by default.

TBD

Changes the actor's command behavior and replaces the current receive handler with the specified handler.

Changes the actor's behavior and replaces the current receive handler with the specified handler. The current handler is stored on a stack, and you can revert to it by calling UnbecomeStacked

Call this method when a message has been confirmed by the destination, or to abort re-sending.

Defer the handler execution until all pending handlers have been executed. Allows to define logic within the actor, which will respect the invocation-order-guarantee in respect to PersistAsyncTEvent(TEvent, ActionTEvent) calls. That is, if PersistAsyncTEvent(TEvent, ActionTEvent) was invoked before DeferAsyncTEvent(TEvent, ActionTEvent), the corresponding handlers will be invoked in the same order as they were registered in. This call will NOT result in evt being persisted, use PersistTEvent(TEvent, ActionTEvent) or PersistAsyncTEvent(TEvent, ActionTEvent) instead if the given evt should be possible to replay. If there are no pending persist handler calls, the handler will be called immediately. If persistence of an earlier event fails, the persistent actor will stop, and the handler will not be run.

Permanently deletes all persistent messages with sequence numbers less than or equal toSequenceNr. If the delete is successful a DeleteMessagesSuccess will be sent to the actor. If the delete fails a DeleteMessagesFailure will be sent to the actor.

Deletes the snapshot identified by sequenceNr. The PersistentActor will be notified about the status of the deletion via an DeleteSnapshotSuccess or DeleteSnapshotFailure message.

Deletes all snapshots matching criteria. The PersistentActor will be notified about the status of the deletion via an DeleteSnapshotsSuccess or DeleteSnapshotsFailure message.

Send the message created with deliveryMessageMapper function to the destination actor. It will retry sending the message until the delivery is confirmed with ConfirmDelivery(Int64). Correlation between these two methods is performed by deliveryId that is provided as parameter to the deliveryMessageMapper function. The deliveryId is typically passed in the message to the destination, which replies with a message containing the same 'deliveryId'. The 'deliveryId' is a strictly monotonically increasing sequence number without gaps. The same sequence is used for all destinations of the actor, i.e. when sending to multiple destinations the destinations will see gaps in the sequence if no translation is performed. During recovery this method will not send out the message, but it will be sent later if no matching ConfirmDelivery(Int64) was performed.

Send the message created with deliveryMessageMapper function to the destination actor. It will retry sending the message until the delivery is confirmed with ConfirmDelivery(Int64). Correlation between these two methods is performed by deliveryId that is provided as parameter to the deliveryMessageMapper function. The deliveryId is typically passed in the message to the destination, which replies with a message containing the same 'deliveryId'. The 'deliveryId' is a strictly monotonically increasing sequence number without gaps. The same sequence is used for all destinations of the actor, i.e. when sending to multiple destinations the destinations will see gaps in the sequence if no translation is performed. During recovery this method will not send out the message, but it will be sent later if no matching ConfirmDelivery(Int64) was performed.

Determines whether the specified object is equal to the current object.

Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

Full state of the AtLeastOnceDeliveryActor. It can be saved with SaveSnapshot(Object). During recovery the snapshot received in SnapshotOffer should be set with SetDeliverySnapshot(AtLeastOnceDeliverySnapshot). The AtLeastOnceDeliverySnapshot contains the full delivery state, including unconfirmed messages. If you need a custom snapshot for other parts of the actor state you must also include the AtLeastOnceDeliverySnapshot. It is serialized using protobuf with the ordinary Akka serialization mechanism. It is easiest to include the bytes of the AtLeastOnceDeliverySnapshot as a blob in your custom snapshot.

Serves as the default hash function.

Gets the Type of the current instance.

Instructs the snapshot store to load the specified snapshot and send it via an SnapshotOffer to the running PersistentActor.

Creates a shallow copy of the current Object.

Called when persist fails. By default it logs the error. Subclass may override to customize logging and for example send negative acknowledgment to sender. The actor is always stopped after this method has been invoked. Note that the event may or may not have been saved, depending on the type of failure.

Called when the journal rejected PersistTEvent(TEvent, ActionTEvent) of an event. The event was not stored. By default this method logs the problem as a warning, and the actor continues. The callback handler that was passed to the PersistTEvent(TEvent, ActionTEvent) method will not be invoked.

Called whenever a message replay fails. By default it log the errors.

Called whenever a message replay succeeds.

Asynchronously persists an event. On successful persistence, the handler is called with the persisted event. This method guarantees that no new commands will be received by a persistent actor between a call to PersistTEvent(TEvent, ActionTEvent) and execution of it's handler. It also holds multiple persist calls per received command. Internally this is done by stashing. The stash used for that is an internal stash which doesn't interfere with the inherited user stash. An event handler may close over eventsourced actor state and modify it. Sender of the persistent event is considered a sender of the corresponding command. That means one can respond to sender from within an event handler. Within an event handler, applications usually update persistent actor state using persisted event data, notify listeners and reply to command senders. If persistence of an event fails, OnPersistFailure(Exception, Object, Int64) will be invoked and the actor will unconditionally be stopped. The reason that it cannot resume when persist fails is that it is unknown if the event was actually persisted or not, and therefore it is in an inconsistent state. Restarting on persistent failures will most likely fail anyway, since the journal is probably unavailable. It is better to stop the actor and after a back-off timeout start it again.

Asynchronously persists series of events in specified order. This is equivalent of multiple calls of PersistTEvent(TEvent, ActionTEvent) calls with the same handler, except that events are persisted atomically with this method.

Asynchronously persists series of events in specified order. This is equivalent of multiple calls of PersistAsyncTEvent(TEvent, ActionTEvent) calls with the same handler, except that events are persisted atomically with this method.

Asynchronously persists an event. On successful persistence, the handler is called with the persisted event. Unlike PersistTEvent(TEvent, ActionTEvent) method, this one will continue to receive incoming commands between calls and executing it's event handler. This version should be used in favor of PersistTEvent(TEvent, ActionTEvent) method when throughput is more important that commands execution precedence. An event handler may close over eventsourced actor state and modify it. Sender of the persistent event is considered a sender of the corresponding command. That means, one can respond to sender from within an event handler. Within an event handler, applications usually update persistent actor state using persisted event data, notify listeners and reply to command senders. If persistence of an event fails, OnPersistFailure(Exception, Object, Int64) will be invoked and the actor will unconditionally be stopped. The reason that it cannot resume when persist fails is that it is unknown if the event was actually persisted or not, and therefore it is in an inconsistent state. Restarting on persistent failures will most likely fail anyway, since the journal is probably unavailable. It is better to stop the actor and after a back-off timeout start it again.

User overridable callback: By default it calls `PreStart()`.

Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.

User overridable callback: '''By default it disposes of all children and then calls `postStop()`.'''

Is called on a crashed Actor right BEFORE it is restarted to allow clean up of resources before Actor is terminated.

User overridable callback.

Is called when an Actor is started. Actors are automatically started asynchronously when created. Empty default implementation.

Processor for user defined messages.

Saves snapshot of current ISnapshotter state. The PersistentActor will be notified about the success or failure of this via an SaveSnapshotSuccess or SaveSnapshotFailure message.

If snapshot from GetDeliverySnapshot was saved it will be received during recovery phase in a SnapshotOffer message and should be set with this method.

TBD

Returns a string that represents the current object.

Reverts the Actor behavior to the previous one on the behavior stack.

TBD

Matches the specified target.

Matches the specified target and return a result of target processing.