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 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 fn children<'a>( self, node_hierarchy: &'a NodeHierarchyRef<'a>, ) -> Children<'a>

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

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,

Traverse up through the hierarchy until a node matching the predicate is found.

Necessary to resolve the last positioned (= relative) element of an absolute node.

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, 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 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