Struct PieceTree 

pub struct PieceTree { /* private fields */ }

The main piece table structure with integrated line tracking

Implementations

impl PieceTree

pub fn new( location: BufferLocation, offset: usize, bytes: usize, line_feed_cnt: Option<usize>, ) -> Self

Create a new piece table with a single initial piece

pub fn empty() -> Self

Create an empty piece table

pub fn from_leaves(leaves: &[LeafData]) -> Self

Build a PieceTree from an explicit list of leaves.

pub fn find_by_offset(&self, offset: usize) -> Option<PieceInfo>

Find the piece at the given byte offset

pub fn cursor_at_offset(&self, offset: usize) -> Cursor

Create a cursor at the given byte offset Note: line/col calculation should be done by LineIndex

pub fn insert( &mut self, offset: usize, location: BufferLocation, buffer_offset: usize, bytes: usize, line_feed_cnt: Option<usize>, buffers: &[StringBuffer], ) -> Cursor

Insert text at the given offset Returns new cursor after the inserted text line_feed_cnt: number of line feeds in the inserted text (None if unknown/not computed) buffers: reference to the string buffers for computing line feeds during splits

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

Get a clone of the root node (shared via Arc)

pub fn insert_at_position( &mut self, line: usize, column: usize, location: BufferLocation, buffer_offset: usize, bytes: usize, line_feed_cnt: usize, buffers: &[StringBuffer], ) -> Cursor

Insert text at the given position (line, column) Returns new cursor after the inserted text This converts position to offset, then uses path-copying insert

pub fn split_at_offset(&mut self, offset: usize, buffers: &[StringBuffer])

Split a piece at the given offset without inserting anything This is useful for isolating a chunk of a large piece for partial loading

If the offset is in the middle of a piece, that piece will be split into two pieces. If the offset is at a piece boundary, nothing changes. Does nothing if offset is 0 or >= total_bytes.

pub fn replace_buffer_reference( &mut self, old_buffer_id: usize, old_buffer_offset: usize, old_buffer_bytes: usize, new_buffer_location: BufferLocation, )

Replace buffer references in pieces This is used when creating chunk buffers from large unloaded buffers

Finds all pieces that reference the old buffer at the specified offset/bytes and updates them to reference the new buffer at offset 0.

pub fn delete( &mut self, offset: usize, delete_bytes: usize, buffers: &[StringBuffer], )

Delete text starting at offset for the given number of bytes

pub fn delete_position_range( &mut self, start_line: usize, start_column: usize, end_line: usize, end_column: usize, buffers: &[StringBuffer], )

Delete text in a range specified by positions (start_line, start_col) to (end_line, end_col) Converts positions to offsets, then uses path-copying delete

pub fn total_bytes(&self) -> usize

Get the total number of bytes in the document

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

Get the total number of lines in the document Line count = line feeds + 1 Returns None if any piece has unknown line count

pub fn piece_info_for_line( &self, target_line: usize, ) -> Option<(usize, usize, usize, usize, usize)>

Find the document byte offset and metadata for the piece containing a target line.

Uses only the tree’s lf_left / line_feed_cnt metadata (no buffer data needed). Returns (doc_byte_offset, buffer_id, piece_offset, piece_bytes, lines_before_piece) where lines_before_piece is the number of complete lines before this piece.

pub fn update_leaf_line_feeds(&mut self, updates: &[(usize, usize)])

Rebuild the tree with updated line feed counts from external data.

Takes a slice of (leaf_index, line_feed_count) pairs. Each entry updates the corresponding leaf (by order in the tree) with the given line feed count. After updating, rebuilds the tree so that lf_left values on internal nodes are correct.

This keeps the piece tree free of I/O — the caller is responsible for reading chunk data and counting line feeds externally.

pub fn update_leaf_line_feeds_path_copy(&mut self, updates: &[(usize, usize)])

Update leaf line feed counts using path-copying. Like update_leaf_line_feeds but only clones nodes along each updated leaf’s root-to-leaf path, preserving Arc::ptr_eq for unmodified subtrees.

pub fn stats(&self) -> TreeStats

Get tree statistics for debugging

pub fn get_leaves(&self) -> Vec<LeafData>

Get all leaves in order (for debugging)

pub fn split_leaves_to_chunk_size(&mut self, max_bytes: usize)

Split any leaves larger than max_bytes into smaller pieces.

This is a bulk operation that collects all leaves, subdivides oversized ones, and rebuilds the tree once. Line-feed counts on the new sub-leaves are set to None (the caller is expected to fill them in via scanning).

pub fn offset_to_position( &self, offset: usize, buffers: &[StringBuffer], ) -> Option<(usize, usize)>

Convert byte offset to line/column position using tree’s line metadata

pub fn position_to_offset( &self, line: usize, column: usize, buffers: &[StringBuffer], ) -> usize

Convert line/column position to byte offset using tree’s line metadata

pub fn line_range( &self, line: usize, buffers: &[StringBuffer], ) -> Option<(usize, Option<usize>)>

Get the byte range for a specific line

pub fn iter_pieces_in_range(&self, start: usize, end: usize) -> PieceRangeIter

Iterate through pieces overlapping a byte range Does ONE O(log n) tree traversal, then iterates sequentially

pub fn apply_bulk_edits<F>( &mut self, edits: &[(usize, usize, &str)], buffers: &[StringBuffer], add_text_fn: F, ) -> isize

where F: FnMut(&str) -> (BufferLocation, usize, usize, Option<usize>),

Apply multiple edits in a single tree traversal + rebuild

Arguments

• edits - Vec of (position, delete_len, insert_text), MUST be sorted descending by position
• buffers - Reference to string buffers (for line feed computation)
• add_text_fn - Function to add text to buffer, returns (BufferLocation, offset, bytes)

Complexity

O(pieces + edits) instead of O(pieces × edits)

Returns

The net change in total bytes

Trait Implementations

impl Clone for PieceTree

fn clone(&self) -> PieceTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PieceTree

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

Formats the value using the given formatter.