Struct Tree 

pub struct Tree { /* private fields */ }

Retained tree store. Holds the current root node (if any) and supports full replacement (snapshot) and incremental patch application.

Maintains an internal id_index mapping each node ID to the child-index path that addresses it from the root. The index is rebuilt on every snapshot and after every apply_patch call so find_by_id is O(path-depth) instead of O(tree-size). Empty IDs (legal for unaddressable nodes) are not indexed; under duplicate IDs the first depth-first occurrence wins, matching the recursive scan it replaces.

Implementations

impl Tree

pub fn new() -> Self

pub fn snapshot(&mut self, root: TreeNode) -> Result<(), Vec<String>>

Replace the entire tree with a new root (snapshot).

The tree is always accepted (the renderer needs UI even if the tree has problems). Returns Ok(()) if all node IDs are unique, or Err with a list of "id (type_name)" strings for each duplicate. The caller should emit a protocol error so the host can fix the bug.

pub fn root(&self) -> Option<&TreeNode>

Return a reference to the current root, if any.

pub fn root_mut(&mut self) -> Option<&mut TreeNode>

Return a mutable reference to the current root, if any. Used by transforms that drive the shared tree_walk walker, which takes &mut TreeNode even for read-only passes.

pub fn find_window(&self, window_id: &str) -> Option<&TreeNode>

Find a window node by its window ID, searching the entire tree recursively.

pub fn window_ids(&self) -> Vec<String>

Collect the IDs of all window nodes in the tree (recursive search).

pub fn find_by_id(&self, node_id: &str) -> Option<&TreeNode>

Find a node by ID. Goes through the id_index for O(depth) lookup instead of a full depth-first scan.

pub fn find_by_type(&self, node_id: &str) -> Option<&str>

Returns the type name of the node with the given ID, if found.

pub fn validate_patch_order(ops: &[PatchOp]) -> Result<(), String>

Validate protocol ordering for a sequence of patch operations.

The wire protocol orders structural ops so indices stay meaningful: removes first, updates/replacements next, inserts last. Removes and inserts are ordered only within the same parent path.

pub fn apply_patch( &mut self, ops: Vec<PatchOp>, ) -> Vec<(String, usize, TreeNode)>

Apply a sequence of patch operations to the tree.

The caller is responsible for validating protocol ordering before applying renderer-owned patch sequences. Operations are applied sequentially. If one operation fails, it is skipped with a warning and subsequent operations are still applied. This preserves existing best-effort handling for malformed or stale individual ops. Applies patch operations and returns any removed nodes that had an “exit” prop (for exit animation ghost promotion).

Trait Implementations

impl Debug for Tree

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

Formats the value using the given formatter.

impl Default for Tree

fn default() -> Tree

Returns the “default value” for a type.