Struct NodeId 

pub struct NodeId {
    pub index: u32,
    pub generation: u32,
}

A typed, generational index into the arena.

Combines an index with a generation counter to prevent use-after-free bugs and ABA problems. When a slot is reused, its generation is incremented, invalidating all old NodeIds pointing to that slot.

Example

use aether_core::arena::{Arena, NodeId};

let mut arena: Arena<i32> = Arena::with_capacity(10);

let id1 = arena.insert(42).unwrap();
arena.remove(id1);

let id2 = arena.insert(99).unwrap();

// Same slot, different generation
assert_eq!(id1.index, id2.index);
assert_ne!(id1.generation, id2.generation);

// Old ID is invalid
assert!(arena.get(id1).is_none());
// New ID is valid
assert_eq!(*arena.get(id2).unwrap(), 99);

Safety

The generation counter prevents:

• Use-after-free: Old IDs become invalid when slots are reused
• ABA problem: Can’t confuse old and new values in the same slot
• Dangling references: Stale IDs return None instead of wrong data

Fields

index: u32

generation: u32

Implementations

impl NodeId

pub const INVALID: Self

Trait Implementations

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 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 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 Copy for NodeId

impl Eq for NodeId

impl StructuralPartialEq for NodeId