Struct EditHistory 

pub struct EditHistory { /* private fields */ }

Bounded undo / redo history.

The maximum number of entries on each stack is configurable via EditHistory::with_max. When the undo stack exceeds the limit the oldest entry is discarded (FIFO eviction).

Implementations

impl EditHistory

pub fn new() -> Self

Create a history with the default max depth (1 000 entries).

pub fn with_max(max_entries: usize) -> Self

Create a history with a custom maximum depth.

pub fn apply(&mut self, txn: &EditTransaction, buffer: &mut TextBuffer)

Apply a pre-built EditTransaction to buffer, record it in the undo stack, and clear the redo stack (any previously undone work is forked away).

pub fn apply_edit( &mut self, buffer: &mut TextBuffer, range: Range<usize>, new_text: &str, )

Convenience: build a single-edit transaction, apply it, and record it.

old_text is captured automatically from the buffer.

pub fn undo(&mut self, buffer: &mut TextBuffer) -> bool

Undo the most recent transaction, returning true if an undo was performed.

pub fn redo(&mut self, buffer: &mut TextBuffer) -> bool

Redo the most recently undone transaction, returning true if a redo was performed.

pub fn record(&mut self, txn: EditTransaction)

Record a pre-built EditTransaction in the undo stack without applying it to the buffer. This is useful when the caller has already mutated the buffer (or is about to) and just needs the history entry.

Clears the redo stack and evicts the oldest entry when the stack exceeds max_entries.

pub fn pop_undo(&mut self) -> Option<EditTransaction>

Pop the most recent transaction from the undo stack.

Returns None if the undo stack is empty. The caller is responsible for applying the inverse and pushing a matching entry onto the redo stack via push_redo.

pub fn pop_redo(&mut self) -> Option<EditTransaction>

Pop the most recent transaction from the redo stack.

Returns None if the redo stack is empty. The caller is responsible for re-applying the edits and pushing a matching entry onto the undo stack via push_undo.

pub fn push_redo(&mut self, txn: EditTransaction)

Push a transaction onto the redo stack (used by external undo logic).

pub fn push_undo(&mut self, txn: EditTransaction)

Push a transaction onto the undo stack without clearing the redo stack (used by external redo logic that manually manages both stacks).

pub fn undo_depth(&self) -> usize

Number of entries currently on the undo stack.

pub fn redo_depth(&self) -> usize

Number of entries currently on the redo stack.

pub fn max_entries(&self) -> usize

Maximum entries per stack.

pub fn clear(&mut self)

Discard all history.

Trait Implementations

impl Clone for EditHistory

fn clone(&self) -> EditHistory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EditHistory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for EditHistory

fn default() -> Self

Returns the “default value” for a type.