Struct StorageWriteJournal 

pub struct StorageWriteJournal {
    pub entries: Vec<JournalEntry>,
    pub next_sequence: u64,
    pub max_entries: usize,
}

An append-only write journal that records all storage mutations.

The journal enforces a bounded capacity: when the number of stored entries exceeds max_entries, the oldest entry is evicted. Sequence numbers are never reused — they continue to increment even after eviction, so consumers holding a JournalCursor can detect that they have fallen behind.

Fields

entries: Vec<JournalEntry>

Retained entries, in ascending sequence order. Never reordered.

next_sequence: u64

The sequence number that will be assigned to the next appended entry.

max_entries: usize

Maximum number of entries to retain. When exceeded, the oldest entry is dropped.

Implementations

impl StorageWriteJournal

pub fn new(max_entries: usize) -> Self

Creates a new, empty journal with the given capacity limit.

next_sequence is initialised to 1.

pub fn append( &mut self, kind: JournalEntryKind, cid: &str, size_bytes: u64, timestamp_secs: u64, ) -> u64

Appends a new entry to the journal.

The checksum is computed as fnv1a(cid.as_bytes()) ^ sequence.

If entries.len() > max_entries after appending, the oldest entry (index 0) is removed.

Returns the sequence number assigned to the new entry.

pub fn entries_since<'a>( &'a self, cursor: &JournalCursor, ) -> Vec<&'a JournalEntry>

Returns all entries with sequence > cursor.last_sequence, in order.

pub fn cursor(&self) -> JournalCursor

Returns a cursor pointing at the newest retained entry.

If the journal is empty the cursor’s last_sequence is 0.

pub fn verify_checksum(&self, entry: &JournalEntry) -> bool

Verifies the checksum of entry.

Returns true when fnv1a(entry.cid.as_bytes()) ^ entry.sequence equals entry.checksum.

pub fn stats(&self) -> JournalStats

Returns aggregate statistics for the current journal contents.

pub fn truncate_before(&mut self, sequence: u64)

Removes all entries whose sequence number is strictly less than sequence.