Struct FileSystemEventLog

pub struct FileSystemEventLog<T, E>
where
    T: Default + Encodable + Decodable + Send + Sync,
    E: Error + Debug + From<Error> + From<Error> + From<Error> + Send + Sync + 'static,
{ /* private fields */ }

Filesystem event log.

Appends events to an append-only writer and reads events via a reader whilst managing an in-memory merkle tree of event hashes.

Implementations

impl<T, E> FileSystemEventLog<T, E>

where T: Default + Encodable + Decodable + Send + Sync + 'static, E: Error + Debug + From<Error> + From<Error> + From<Error> + Send + Sync + 'static,

pub fn file_path(&self) -> &PathBuf

Path to the event log file.

pub async fn iter( &self, reverse: bool, ) -> StdResult<Box<dyn FormatStreamIterator<EventLogRecord> + Send + Sync>, E>

Iterate the event records.

impl<E> FileSystemEventLog<WriteEvent, E>

where E: Error + Debug + From<Error> + From<Error> + From<Error> + Send + Sync + 'static,

pub async fn new_folder<P: AsRef<Path>>(path: P) -> StdResult<Self, E>

Create a new folder event log file.

impl<E> FileSystemEventLog<AccountEvent, E>

where E: Error + Debug + From<Error> + From<Error> + From<Error> + Send + Sync + 'static,

pub async fn new_account<P: AsRef<Path>>(path: P) -> StdResult<Self, E>

Create a new account event log file.

impl<E> FileSystemEventLog<DeviceEvent, E>

where E: Error + Debug + From<Error> + From<Error> + From<Error> + Send + Sync + 'static,

pub async fn new_device(path: impl AsRef<Path>) -> StdResult<Self, E>

Create a new device event log file.

Trait Implementations

impl<T, E> EventLog<T> for FileSystemEventLog<T, E>

where T: Default + Encodable + Decodable + Send + Sync + 'static, E: Error + Debug + From<Error> + From<Error> + From<Error> + Send + Sync + 'static,

type Error = E

Error type.

fn record_stream<'life0, 'async_trait>( &'life0 self, reverse: bool, ) -> Pin<Box<dyn Future<Output = BoxStream<'async_trait, StdResult<EventRecord, Self::Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stream of event records.

fn event_stream<'life0, 'async_trait>( &'life0 self, reverse: bool, ) -> Pin<Box<dyn Future<Output = BoxStream<'async_trait, StdResult<(EventRecord, T), Self::Error>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stream of event records and decoded events.

fn diff_checked<'life0, 'async_trait>( &'life0 self, commit: Option<CommitHash>, checkpoint: CommitProof, ) -> Pin<Box<dyn Future<Output = StdResult<Diff<T>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a checked diff from a commit.

fn diff_unchecked<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = StdResult<Diff<T>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create an unchecked diff of all events.

fn diff_events<'life0, 'life1, 'async_trait>( &'life0 self, commit: Option<&'life1 CommitHash>, ) -> Pin<Box<dyn Future<Output = StdResult<Patch<T>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Diff of events until a specific commit; does not include the target commit.

fn tree(&self) -> &CommitTree

Commit tree contains the in-memory merkle tree.

fn rewind<'life0, 'life1, 'async_trait>( &'life0 mut self, commit: &'life1 CommitHash, ) -> Pin<Box<dyn Future<Output = StdResult<Vec<EventRecord>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Rewind this event log discarding commits after the specific commit.

fn load_tree<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = StdResult<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Load data from storage to build a commit tree in memory.

fn clear<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = StdResult<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete all events from the log file on disc and in-memory.

fn apply<'life0, 'life1, 'async_trait>( &'life0 mut self, events: &'life1 [T], ) -> Pin<Box<dyn Future<Output = StdResult<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append a collection of events and commit the tree hashes only if all the events were successfully written.

fn apply_records<'life0, 'async_trait>( &'life0 mut self, records: Vec<EventRecord>, ) -> Pin<Box<dyn Future<Output = StdResult<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append raw event records to the event log.

fn patch_checked<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, commit_proof: &'life1 CommitProof, patch: &'life2 Patch<T>, ) -> Pin<Box<dyn Future<Output = StdResult<CheckedPatch, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Append a patch to this event log only if the head of the tree matches the given proof.

fn replace_all_events<'life0, 'life1, 'async_trait>( &'life0 mut self, diff: &'life1 Diff<T>, ) -> Pin<Box<dyn Future<Output = StdResult<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Replace all events in this event log with the events in the diff.

fn patch_unchecked<'life0, 'life1, 'async_trait>( &'life0 mut self, patch: &'life1 Patch<T>, ) -> Pin<Box<dyn Future<Output = StdResult<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append a patch to this event log.

fn diff_records<'life0, 'life1, 'async_trait>( &'life0 self, commit: Option<&'life1 CommitHash>, ) -> Pin<Box<dyn Future<Output = StdResult<Vec<EventRecord>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Diff of event records until a specific commit.

fn version(&self) -> u16

Encoding version.