Struct PieceTree 

pub struct PieceTree {
    pub root: NodeRef,
    pub transaction_depth: usize,
    pub undo_stack: Vec<HistoryEntry>,
    pub redo_stack: Vec<HistoryEntry>,
    pub pieces: Pieces,
    pub buffers: Buffers,
    pub scratch_index_map: Vec<u32>,
    /* private fields */
}

Fields

root: NodeRef

transaction_depth: usize

Tracks nested undo groups. 0 if we are outside any group.

undo_stack: Vec<HistoryEntry>

redo_stack: Vec<HistoryEntry>

pieces: Pieces

buffers: Buffers

scratch_index_map: Vec<u32>

Implementations

impl PieceTree

pub fn split(&mut self, root: NodeRef, offset: u32) -> (NodeRef, NodeRef)

Slices a tree exactly at offset, returning (LeftTree, RightTree)

pub fn concat(&mut self, left: NodeRef, right: NodeRef) -> NodeRef

Glues two arbitrary trees together by extracting the max element of the left tree

impl PieceTree

pub fn new() -> Self

pub fn from_str(text: &str) -> Self

impl PieceTree

pub fn take_snapshot(&self, current_cursor: u32) -> HistoryEntry

Captures the current state of the document.

pub fn snap_to(&mut self, snapshot: HistoryEntry, current_cursor: u32) -> u32

Restores the tree to a previously saved snapshot. Returns the cursor offset from the snapshot.

impl PieceTree

pub fn begin_undo_group(&mut self, cursor_offset: u32)

Starts a new undo group, saves the current state if this is the outermost group.

pub fn end_undo_group(&mut self)

Ends the current undo group

pub fn commit_head(&mut self, cursor_offset: u32)

pub fn try_undo(&mut self, current_cursor: u32) -> Option<u32>

pub fn try_redo(&mut self, current_cursor: u32) -> Option<u32>

pub fn total_length(&self) -> u32

pub fn apply_edits(&mut self, primary_cursor_offset: u32, edits: &mut [Edit])

pub fn insert_char(&mut self, offset: u32, ch: char)

Inserts a single character at the specified logical byte offset.

pub fn insert_char_no_commit(&mut self, offset: u32, ch: char)

Inserts a single character at the specified logical byte offset.

pub fn insert(&mut self, offset: u32, text: &str)

pub fn remove_at(&mut self, offset: u32, length: u32)

pub fn insert_no_commit(&mut self, offset: u32, text: &str)

pub fn remove_no_commit(&mut self, offset: u32, length: u32)

pub fn get_piece(&self, index: NodeRef) -> Piece

pub fn find_position( &self, offset: u32, prefer_left: bool, ) -> Option<(NodeRef, u32)>

pub fn write_to<W: Write>(&self, writer: W) -> Result<()>

impl PieceTree

pub fn compact(&mut self)

pub fn squash(&mut self)

impl PieceTree

pub fn node_arena_bytes(&self) -> u32

Total bytes allocated for the node arena (includes NIL sentinel and all historical nodes retained for undo/redo).

pub fn mod_buffer_bytes(&self) -> u32

Bytes consumed by the modifications buffer (append-only, never shrinks).

pub fn original_buffers_bytes(&self) -> u32

Bytes consumed by all original (read) buffers.

pub fn history_bytes(&self) -> u32

Bytes consumed by undo + redo history entries.

pub fn node_count(&self) -> u32

Number of live nodes in the arena (includes NIL and all historical nodes).

pub fn memory_usage(&self) -> MemoryUsage

Aggregate memory usage breakdown.

impl PieceTree

pub fn slice<R: RangeBounds<u32>>(&self, range: R) -> TreeSlice<'_>

pub fn slice_chars_range<R: RangeBounds<u32>>(&self, range: R) -> TreeSlice<'_>

Slice by char range.

impl PieceTree

pub fn read_largest_contigous_chunk_at_byte(&self, offset: u32) -> &[u8]

Fast-path chunk reader specifically designed for the Tree-sitter C API. Given an absolute byte offset, it returns the largest contiguous byte slice available starting exactly at that offset.

pub fn line_to_byte(&self, target_line: u32) -> Option<u32>

pub fn char_to_byte(&self, char_index: u32) -> Option<u32>

pub fn byte_to_char(&self, byte_offset: u32) -> Option<u32>

pub fn byte_to_line_col(&self, offset: u32) -> Option<(u32, u32)>

pub fn pieces(&self) -> PieceTreeIter<'_>

pub fn get_line_range(&self, line: u32) -> Option<(u32, u32)>

pub fn get_line_content_allocating(&self, line: u32) -> Option<String>

pub fn chunks_at_byte(&self, start: u32, end: u32) -> ChunkIter<'_>

Returns an iterator of &str chunks over the given byte range. Zero allocation.

pub fn byte(&self, offset: u32) -> Option<u8>

Byte at a given byte offset. O(log n).

pub fn char(&self, char_index: u32) -> Option<char>

Char at a given char index. O(log n) to find the piece, then a short scan within the piece.

pub fn slice_chars(&self, char_start: u32, char_end: u32) -> SliceChars<'_>

Returns a non-allocating iterator of chars over the given char range. Backed by TreeWalker::seek so it reuses existing infrastructure.

pub fn slice_bytes(&self, byte_start: u32, byte_end: u32) -> SliceChars<'_>

Returns a non-allocating iterator of chars over the given byte range.

pub fn line(&self, line: u32) -> Option<ChunkIter<'_>>

Non-allocating line view: returns a ChunkIter over the byte range of line. Line numbers are 0-based. The trailing \n is included if present.

pub fn len_lines(&self) -> u32

Number of lines (= newline count + 1)

pub fn len_chars(&self) -> u32

pub fn len_bytes(&self) -> u32

pub fn chars(&self) -> TreeWalker<'_>

pub fn chars_rev(&self) -> ReverseTreeWalker<'_>

pub fn lines(&self) -> LinesIter<'_>

pub fn remove<R>(&mut self, range: R)

where R: RangeBounds<u32>,

pub fn char_to_line(&self, char_index: u32) -> Option<u32>

pub fn char_to_line_col(&self, char_index: u32) -> Option<(u32, u32)>

pub fn line_to_char(&self, line: u32) -> Option<u32>

impl PieceTree

pub fn debug(&self, f: &mut impl Write) -> Result

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.

impl Default for PieceTree

fn default() -> PieceTree

Returns the “default value” for a type.

impl Display for PieceTree

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

Formats the value using the given formatter.

impl<T> From<T> for PieceTree

where T: AsRef<str>,

fn from(value: T) -> Self

Converts to this type from the input type.

impl FromStr for PieceTree

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.