Struct NodeId 

pub struct NodeId { /* private fields */ }

A type-safe identifier for a node within a DOM tree.

NodeId is FFI-safe (#[repr(C)]) and stores a zero-based index internally. Use NodeId::index() to get the array index for direct node access.

Zero-based indexing

• NodeId::new(0) → first node (index 0)
• NodeId::new(5) → sixth node (index 5)
• Use node_id.index() to get the array index

FFI Encoding (for Option<NodeId>)

When storing Option<NodeId> in FFI structs (like NodeHierarchyItem), we use a 1-based encoding to represent None:

• 0 means None (no node)
• n > 0 means Some(NodeId(n - 1))

Use NodeId::from_usize to decode and NodeId::into_raw to encode. See also: crate::styled_dom::NodeHierarchyItemId for the FFI wrapper type.

Warning

Never manually construct raw usize values for node hierarchy fields! Always use the provided from_usize/into_raw functions to avoid off-by-one errors that can cause index-out-of-bounds panics.

Implementations

impl NodeId

pub const ZERO: NodeId

The zero/first node ID (index 0).

pub const fn new(value: usize) -> Self

Creates a new NodeId from a zero-based index.

pub const fn from_usize(value: usize) -> Option<Self>

Decodes a raw usize to Option<NodeId> using 1-based encoding.

This is the inverse of [NodeId::into_usize].

• 0 → None (no node)
• n > 0 → Some(NodeId(n - 1))

Warning

This function is for decoding values stored in FFI structs like NodeHierarchyItem. Do not use raw usize values directly - always decode them first!

pub const fn into_raw(val: &Option<Self>) -> usize

Encodes Option<NodeId> to a raw usize for storage in FFI structs.

• None → 0
• Some(NodeId(n)) → n + 1

The returned value uses 1-based encoding! A value of 0 means “no node”, NOT “node at index 0”. Use NodeId::from_usize to decode.

pub const fn index(&self) -> usize

Returns the zero-based index of this node.

This is the actual array index where the node data is stored.

impl NodeId

pub const fn ancestors<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> Ancestors<'a>

Return an iterator of references to this node and its ancestors.

Call .next().unwrap() once on the iterator to skip the node itself.

pub const fn preceding_siblings<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> PrecedingSiblings<'a>

Return an iterator of references to this node and the siblings before it.

Call .next().unwrap() once on the iterator to skip the node itself.

pub const fn following_siblings<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> FollowingSiblings<'a>

Return an iterator of references to this node and the siblings after it.

Call .next().unwrap() once on the iterator to skip the node itself.

pub fn children<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> Children<'a>

Return an iterator of references to this node’s children.

pub fn reverse_children<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> ReverseChildren<'a>

Return an iterator of references to this node’s children, in reverse order.

pub const fn descendants<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> Descendants<'a>

Return an iterator of references to this node and its descendants, in tree order.

Parent nodes appear before the descendants. Call .next().unwrap() once on the iterator to skip the node itself.

pub const fn traverse<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> Traverse<'a>

Return an iterator of references to this node and its descendants, in tree order.

pub const fn reverse_traverse<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> ReverseTraverse<'a>

Return an iterator of references to this node and its descendants, in tree order.

impl NodeId

pub fn get_nearest_matching_parent<'a, F>( self, node_hierarchy: &'a NodeDataContainerRef<'a, NodeHierarchyItem>, predicate: F, ) -> Option<NodeId>

where F: Fn(NodeId) -> bool,

pub fn az_children_collect<'a>( self, node_hierarchy: &'a NodeDataContainerRef<'a, NodeHierarchyItem>, ) -> Vec<NodeId>

Return the children of this node (necessary for parallel iteration over children)

pub fn az_children<'a>( self, node_hierarchy: &'a NodeDataContainerRef<'a, NodeHierarchyItem>, ) -> AzChildren<'a>

Return an iterator of references to this node’s children.

pub fn az_reverse_children<'a>( self, node_hierarchy: &'a NodeDataContainerRef<'a, NodeHierarchyItem>, ) -> AzReverseChildren<'a>

Return an iterator of references to this node’s children.

Trait Implementations

impl Add<usize> for NodeId

type Output = NodeId

The resulting type after applying the + operator.

fn add(self, other: usize) -> NodeId

Performs the + operation.

impl AddAssign<usize> for NodeId

fn add_assign(&mut self, other: usize)

Performs the += operation.

impl Clone for NodeId

fn clone(&self) -> NodeId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeId

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

Formats the value using the given formatter.

impl Display for NodeId

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

Formats the value using the given formatter.

impl From<NodeId> for usize

fn from(val: NodeId) -> Self

Converts to this type from the input type.

impl From<usize> for NodeId

fn from(val: usize) -> Self

Converts to this type from the input type.

impl Hash for NodeId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T> Index<NodeId> for NodeDataContainerRef<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, node_id: NodeId) -> &T

Performs the indexing (container[index]) operation.

impl<'a, T> Index<NodeId> for NodeDataContainerRefMut<'a, T>

type Output = T

The returned type after indexing.

fn index(&self, node_id: NodeId) -> &T

Performs the indexing (container[index]) operation.

impl<'a> Index<NodeId> for NodeHierarchyRef<'a>

type Output = Node

The returned type after indexing.

fn index(&self, node_id: NodeId) -> &Node

Performs the indexing (container[index]) operation.

impl<'a> Index<NodeId> for NodeHierarchyRefMut<'a>

type Output = Node

The returned type after indexing.

fn index(&self, node_id: NodeId) -> &Node

Performs the indexing (container[index]) operation.

impl<'a, T> IndexMut<NodeId> for NodeDataContainerRefMut<'a, T>

fn index_mut(&mut self, node_id: NodeId) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<'a> IndexMut<NodeId> for NodeHierarchyRefMut<'a>

fn index_mut(&mut self, node_id: NodeId) -> &mut Node

Performs the mutable indexing (container[index]) operation.

impl Ord for NodeId

fn cmp(&self, other: &NodeId) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for NodeId

fn eq(&self, other: &NodeId) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for NodeId

fn partial_cmp(&self, other: &NodeId) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for NodeId

impl Eq for NodeId

impl StructuralPartialEq for NodeId