Struct Persistence 

pub struct Persistence { /* private fields */ }

Filesystem + save-state for one TextBuffer.

Implementations

impl Persistence

pub fn new( fs: Arc<dyn FileSystem + Send + Sync>, file_path: Option<PathBuf>, saved_root: Arc<PieceTreeNode>, saved_file_size: Option<usize>, ) -> Self

pub fn fs(&self) -> &Arc<dyn FileSystem + Send + Sync>

pub fn set_fs(&mut self, fs: Arc<dyn FileSystem + Send + Sync>)

pub fn file_path(&self) -> Option<&Path>

pub fn file_path_owned(&self) -> Option<PathBuf>

pub fn set_file_path(&mut self, path: PathBuf)

pub fn clear_file_path(&mut self)

pub fn is_modified(&self) -> bool

pub fn set_modified(&mut self, modified: bool)

pub fn clear_modified(&mut self)

pub fn is_recovery_pending(&self) -> bool

pub fn set_recovery_pending(&mut self, pending: bool)

pub fn saved_root(&self) -> &Arc<PieceTreeNode>

pub fn set_saved_root(&mut self, root: Arc<PieceTreeNode>)

pub fn saved_file_size(&self) -> Option<usize>

pub fn set_saved_file_size(&mut self, size: Option<usize>)

pub fn mark_saved_snapshot(&mut self, piece_tree: &PieceTree)

Replace the saved snapshot with the current piece tree and clear the modified flag. Call this after a successful save.

pub fn refresh_saved_root_if_unmodified(&mut self, piece_tree: &PieceTree)

Refresh the saved root to match the current tree structure without clearing the modified flag. Call this after structural-only changes (e.g. chunk_split_and_load during search scan) so that diff_since_saved can take the fast Arc::ptr_eq path.

pub fn apply_chunk_load_to_saved_root( &mut self, old_buffer_id: usize, chunk_offset_in_buffer: usize, chunk_bytes: usize, new_buffer_id: usize, )

Apply a chunk-load buffer replacement to saved_root.

When viewport loading converts a Stored(buffer_id) piece to Added(new_buffer_id) in the current tree and the buffer is already modified, we must apply the same transformation to saved_root so that diff_since_saved can match loaded-but-unedited regions by (location, offset) identity.

pub fn diff_since_saved( &self, piece_tree: &PieceTree, buffers: &[StringBuffer], ) -> PieceTreeDiff

Diff the current piece tree against the last saved snapshot.

Two-phase algorithm:

• Phase 1: structure-based diff to find changed byte ranges (O(num_leaves)).
• Phase 2: for small changed regions, compare actual bytes (so paste-after-delete shows as no change).

piece_tree + buffers are passed by reference — this method only reads them.

pub fn diff_trees_by_structure(&self, piece_tree: &PieceTree) -> PieceTreeDiff

Structure-based diff comparing piece tree leaves