Struct async_recorder::Recorder

pub struct Recorder<T: Storage> { /* private fields */ }

Persists records asynchronously.

You may want to use this instead of directly calling your persistence backend if you do not want to wait for the record to be persisted, in the handler which created the record. To achieve this Recoder spawns an actor to which all records are sent immediatly. The actor when uses the Storage trait to talk to your persistence backend.

Recorder takes ownership of an actor and the green thread it is running in.

Implementations

impl<T> Recorder<T>where T: Storage + 'static + Send, T::Record: Send, T::Query: Send,

pub async fn new(storage: T) -> Self

pub fn save(&self, record: T::Record)

Sends the record to the internal actor for storage. This interface is fire and forget. It will not wait for the record to be actually persisted, just place it in the channel for the actor to pick up. This is why this method is both synchronous and non blocking.

pub async fn close(self) -> T

Stop accepting new records to save, persist the ones send so far.

Gives back ownership of the underlying storage.

pub async fn records(&self, query: T::Query) -> Vec<T::Record>

All the records stored in the internal storage.