Struct NodeId

pub struct NodeId { /* private fields */ }

A node identifier within a particular Arena.

Implementations

impl NodeId

pub const ZERO: NodeId

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

NOTE: In debug mode, it panics on overflow, since having a pointer that is zero is undefined behaviour (it would basically be cast to a None), which is incorrect, so we rather panic on overflow to prevent that.

To trigger an overflow however, you’d need more that 4 billion DOM nodes - it is more likely that you run out of RAM before you do that. The only thing that could lead to an overflow would be a bug. Therefore, overflow-checking is disabled in release mode.

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

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

pub fn index(&self) -> usize

pub fn range(start: Self, end: Self) -> Vec<NodeId>

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

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