Struct ModifierNodeChain 

pub struct ModifierNodeChain { /* private fields */ }

Chain of modifier nodes attached to a layout node.

The chain tracks ownership of modifier nodes and reuses them across updates when the incoming element list still contains a node of the same type. Removed nodes detach automatically so callers do not need to manually manage their lifetimes.

Implementations

impl ModifierNodeChain

pub fn new() -> Self

pub fn detach_nodes(&mut self)

Detaches all nodes in the chain.

pub fn attach_nodes(&mut self, context: &mut dyn ModifierNodeContext)

Attaches all nodes in the chain.

pub fn repair_chain(&mut self)

Rebuilds the internal chain links (parent/child relationships). This should be called if nodes have been detached but are intended to be reused.

pub fn update_from_slice( &mut self, elements: &[DynModifierElement], context: &mut dyn ModifierNodeContext, )

Reconcile the chain against the provided elements, attaching newly created nodes and detaching nodes that are no longer required.

This method delegates to update_from_ref_iter which handles the actual reconciliation logic.

pub fn update_from_ref_iter<'a, I>( &mut self, elements: I, context: &mut dyn ModifierNodeContext, )

where I: Iterator<Item = &'a DynModifierElement>,

Reconcile the chain against the provided iterator of element references.

This is the preferred method as it avoids requiring a collected slice, enabling zero-allocation traversal of modifier trees.

pub fn update<I>(&mut self, elements: I, context: &mut dyn ModifierNodeContext)

where I: IntoIterator<Item = DynModifierElement>,

Convenience wrapper that accepts any iterator of type-erased modifier elements. Elements are collected into a temporary vector before reconciliation.

pub fn reset(&mut self)

Resets all nodes in the chain. This mirrors the behaviour of Jetpack Compose’s onReset callback.

pub fn detach_all(&mut self)

Detaches every node in the chain and clears internal storage.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capabilities(&self) -> NodeCapabilities

Returns the aggregated capability mask for the entire chain.

pub fn has_capability(&self, capability: NodeCapabilities) -> bool

Returns true if the chain contains at least one node with the requested capability.

pub fn head(&self) -> ModifierChainNodeRef<'_>

Returns the sentinel head reference for traversal.

pub fn tail(&self) -> ModifierChainNodeRef<'_>

Returns the sentinel tail reference for traversal.

pub fn head_to_tail(&self) -> ModifierChainIter<'_>

Iterates over the chain from head to tail, skipping sentinels.

pub fn tail_to_head(&self) -> ModifierChainIter<'_>

Iterates over the chain from tail to head, skipping sentinels.

pub fn for_each_forward<F>(&self, f: F)

where F: FnMut(ModifierChainNodeRef<'_>),

Calls f for every node in insertion order.

pub fn for_each_forward_matching<F>(&self, mask: NodeCapabilities, f: F)

where F: FnMut(ModifierChainNodeRef<'_>),

Calls f for every node containing any capability from mask.

pub fn for_each_node_with_capability<F>(&self, mask: NodeCapabilities, f: F)

where F: FnMut(ModifierChainNodeRef<'_>, &dyn ModifierNode),

Calls f for every node containing any capability from mask, providing the node ref.

pub fn for_each_backward<F>(&self, f: F)

where F: FnMut(ModifierChainNodeRef<'_>),

Calls f for every node in reverse insertion order.

pub fn for_each_backward_matching<F>(&self, mask: NodeCapabilities, f: F)

where F: FnMut(ModifierChainNodeRef<'_>),

Calls f for every node in reverse order that matches mask.

pub fn node_ref_at(&self, index: usize) -> Option<ModifierChainNodeRef<'_>>

Returns a node reference for the entry at index.

pub fn find_node_ref( &self, node: &dyn ModifierNode, ) -> Option<ModifierChainNodeRef<'_>>

Returns the node reference that owns node.

pub fn node<N: ModifierNode + 'static>( &self, index: usize, ) -> Option<Ref<'_, N>>

Downcasts the node at index to the requested type. Returns a Ref guard that dereferences to the node type.

pub fn node_mut<N: ModifierNode + 'static>( &self, index: usize, ) -> Option<RefMut<'_, N>>

Downcasts the node at index to the requested mutable type. Returns a RefMut guard that dereferences to the node type.

pub fn get_node_rc( &self, index: usize, ) -> Option<Rc<RefCell<Box<dyn ModifierNode>>>>

Returns an Rc clone of the node at the given index for shared ownership. This is used by coordinators to hold direct references to nodes.

pub fn has_nodes_for_invalidation(&self, kind: InvalidationKind) -> bool

Returns true if the chain contains any nodes matching the given invalidation kind.

pub fn visit_nodes<F>(&self, f: F)

where F: FnMut(&dyn ModifierNode, NodeCapabilities),

Visits every node in insertion order together with its capability mask.

pub fn visit_nodes_mut<F>(&mut self, f: F)

where F: FnMut(&mut dyn ModifierNode, NodeCapabilities),

Visits every node mutably in insertion order together with its capability mask.

Trait Implementations

impl Default for ModifierNodeChain

fn default() -> Self

Returns the “default value” for a type.