Struct EventLog 

pub struct EventLog { /* private fields */ }

The event log - append-only log of all events

Implementations

impl EventLog

pub fn new() -> Self

Create a new empty event log

pub fn mark_saved(&mut self)

Mark the current position as the saved point Call this when the buffer is saved to disk

pub fn clear_saved_position(&mut self)

Invalidate the saved position so the buffer is always considered modified. Call this after hot exit recovery, where the buffer content differs from disk but the event log has no record of the changes.

pub fn is_at_saved_position(&self) -> bool

Check if the buffer is at the saved position (not modified) Returns true if we’re at the saved position OR if all events between saved_at_index and current_index are readonly (don’t modify buffer content)

pub fn enable_streaming<P: AsRef<Path>>(&mut self, path: P) -> Result<()>

Enable streaming events to a file (runtime only)

pub fn disable_streaming(&mut self)

Disable streaming (runtime only)

pub fn log_render_state( &mut self, cursor_pos: usize, screen_cursor_x: u16, screen_cursor_y: u16, buffer_len: usize, )

Log rendering state (for debugging, runtime only)

pub fn log_keystroke(&mut self, key_code: &str, modifiers: &str)

Log keystroke (for debugging, runtime only)

pub fn append(&mut self, event: Event) -> usize

Append an event to the log

pub fn set_displaced_markers_on_last(&mut self, markers: Vec<(u64, usize)>)

Set displaced markers on the last appended entry. Call this right after append() to record markers that were inside the deleted range, so undo can restore them to exact positions.

pub fn current_index(&self) -> usize

Get the current event index

pub fn len(&self) -> usize

Get the number of events in the log

pub fn is_empty(&self) -> bool

Check if the event log is empty

pub fn can_undo(&self) -> bool

Can we undo?

pub fn can_redo(&self) -> bool

Can we redo?

pub fn undo(&mut self) -> Vec<(Event, Vec<(u64, usize)>)>

Move back through events (for undo) Collects all events up to and including the first write action, returns their inverses. Each inverse event is paired with displaced markers from the original event, which should be restored after applying the inverse Insert. This processes readonly events (like scrolling) and stops at write events (like Insert/Delete)

pub fn redo(&mut self) -> Vec<Event>

Move forward through events (for redo) Collects the first write action plus all readonly events after it (until next write action) This processes readonly events (like scrolling) with write events (like Insert/Delete)

pub fn entries(&self) -> &[LogEntry]

Get all events from the log

pub fn range(&self, range: Range<usize>) -> &[LogEntry]

Get events in a range

pub fn last_event(&self) -> Option<&Event>

Get the most recent event

pub fn clear(&mut self)

Clear all events (for testing or reset)

pub fn save_to_file(&self, path: &Path) -> Result<()>

Save event log to JSON Lines format

pub fn load_from_file(path: &Path) -> Result<Self>

Load event log from JSON Lines format

pub fn set_snapshot_interval(&mut self, interval: usize)

Set snapshot interval

Trait Implementations

impl Default for EventLog

fn default() -> Self

Returns the “default value” for a type.