Struct ReceivePersistent 

pub struct ReceivePersistent<S, E, Err>
where
    S: Default + Send + 'static,
    E: Clone + Send + 'static,
    Err: Error + Send + 'static,
{ /* private fields */ }

Closure-style persistent actor.

Implementations

impl<S, E, Err> ReceivePersistent<S, E, Err>

where S: Default + Send + 'static, E: Clone + Send + 'static, Err: Error + Send + 'static,

pub fn new(persistence_id: impl Into<String>) -> Self

pub fn on_command<F>(self, f: F) -> Self

where F: FnMut(&S, E) -> Result<Vec<E>, Err> + Send + 'static,

Register the command handler. The closure receives the current state + the incoming command (the command type matches the event type for this minimal helper; richer command-vs-event shapes use Eventsourced directly).

pub fn on_event<F>(self, f: F) -> Self

where F: FnMut(&mut S, &E) + Send + 'static,

Register the event applier — mutates state in-place.

pub fn with_codec<EncF, DecF>(self, encode: EncF, decode: DecF) -> Self

where EncF: Fn(&E) -> Result<Vec<u8>, String> + Send + Sync + 'static, DecF: Fn(&[u8]) -> Result<E, String> + Send + Sync + 'static,

Register the codec used to round-trip events through the journal.

pub fn state(&self) -> &S

pub fn persistence_id(&self) -> &str

pub async fn recover<J: Journal>( &mut self, journal: Arc<J>, permitter: &RecoveryPermitter, ) -> Result<u64, EventsourcedError<Err>>

Replay the journal under permitter and apply each event.

pub async fn handle<J: Journal>( &mut self, journal: Arc<J>, cmd: E, ) -> Result<(), EventsourcedError<Err>>

Apply one command — derive events, persist, apply.