Struct UndoRedoManager 

pub struct UndoRedoManager {
    pub node_stacks: Vec<NodeUndoRedoStack>,
}

Manager for undo/redo operations across all text nodes

Fields

node_stacks: Vec<NodeUndoRedoStack>

Per-node undo/redo stacks Using Vec instead of HashMap for no_std compatibility

Implementations

impl UndoRedoManager

pub fn new() -> Self

Create a new empty undo/redo manager

pub fn get_or_create_stack_mut( &mut self, node_id: NodeId, ) -> &mut NodeUndoRedoStack

Get or create a stack for a specific node

pub fn get_stack(&self, node_id: NodeId) -> Option<&NodeUndoRedoStack>

Get a stack for a specific node (immutable)

pub fn record_operation( &mut self, changeset: TextChangeset, pre_state: NodeStateSnapshot, )

Record a text operation (push to undo stack)

This should be called AFTER a changeset has been successfully applied. The pre_state should contain the node state BEFORE the changeset was applied.

Arguments

• changeset - The changeset that was applied
• pre_state - Node state before the changeset

pub fn can_undo(&self, node_id: NodeId) -> bool

Check if undo is available for a node

pub fn can_redo(&self, node_id: NodeId) -> bool

Check if redo is available for a node

pub fn peek_undo(&self, node_id: NodeId) -> Option<&UndoableOperation>

Peek at the next undo operation for a node (without removing it)

This allows user callbacks to inspect what would be undone.

pub fn peek_redo(&self, node_id: NodeId) -> Option<&UndoableOperation>

Peek at the next redo operation for a node (without removing it)

This allows user callbacks to inspect what would be redone.

pub fn pop_undo(&mut self, node_id: NodeId) -> Option<UndoableOperation>

Pop an operation from the undo stack

This should be called during undo processing to get the operation to revert. After reverting, the operation should be pushed to the redo stack.

Returns

• Some(operation) - The operation to undo
• None - No undo history available

pub fn pop_redo(&mut self, node_id: NodeId) -> Option<UndoableOperation>

Pop an operation from the redo stack

This should be called during redo processing to get the operation to re-apply. After re-applying, the operation should be pushed to the undo stack.

Returns

• Some(operation) - The operation to redo
• None - No redo history available

pub fn push_redo(&mut self, operation: UndoableOperation)

Push an operation to the redo stack (after successful undo)

This should be called AFTER an undo operation has been successfully applied.

pub fn push_undo(&mut self, operation: UndoableOperation)

Push an operation to the undo stack (after successful redo)

This should be called AFTER a redo operation has been successfully applied.

pub fn clear_node(&mut self, node_id: NodeId)

Clear all undo/redo history for a specific node

pub fn clear_all(&mut self)

Clear all undo/redo history for all nodes

pub fn undo_depth(&self, node_id: NodeId) -> usize

Get the total number of operations in undo stack for a node

pub fn redo_depth(&self, node_id: NodeId) -> usize

Get the total number of operations in redo stack for a node

Trait Implementations

impl Clone for UndoRedoManager

fn clone(&self) -> UndoRedoManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UndoRedoManager

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

Formats the value using the given formatter.

impl Default for UndoRedoManager

fn default() -> UndoRedoManager

Returns the “default value” for a type.