Struct LayoutCacheMap 

pub struct LayoutCacheMap {
    pub entries: Vec<NodeCache>,
}

External layout cache, parallel to LayoutTree.nodes.

cache_map.entries[i] holds the cache for LayoutTree.nodes[i]. Stored on LayoutCache (persists across frames).

This is Azul’s improvement over Taffy’s on-node cache:

• LayoutNode stays slim (0 bytes overhead)
• No &mut tree needed to read/write cache entries
• Cache can be resized independently after reconciliation
• O(1) indexed lookup (Vec) instead of O(log n) (BTreeMap)

Fields

entries: Vec<NodeCache>

Implementations

impl LayoutCacheMap

pub fn resize_to_tree(&mut self, tree_len: usize)

Resize to match tree length after reconciliation. New nodes get empty (dirty) caches. Removed nodes’ caches are dropped.

pub fn get(&self, node_index: usize) -> &NodeCache

O(1) lookup by layout tree index.

pub fn get_mut(&mut self, node_index: usize) -> &mut NodeCache

O(1) mutable lookup by layout tree index.

pub fn mark_dirty(&mut self, node_index: usize, tree: &[LayoutNode])

Invalidate a node and propagate dirty flags upward through ancestors.

Implements Taffy’s early-stop optimization: propagation halts at the first ancestor whose cache is already empty (i.e., already dirty). This prevents redundant O(depth) propagation when multiple children of the same parent are dirtied.

Trait Implementations

impl Clone for LayoutCacheMap

fn clone(&self) -> LayoutCacheMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LayoutCacheMap

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

Formats the value using the given formatter.

impl Default for LayoutCacheMap

fn default() -> LayoutCacheMap

Returns the “default value” for a type.