Struct Index 

pub struct Index<T> { /* private fields */ }

A type-safe, compact handle to an element in an ElemPool.

An Index<T> is essentially a wrapper around a u32, providing a cheap, Copy-able way to reference list elements without relying on raw pointers or garbage collection.

Rationale

Using a custom Index type instead of a raw usize or u32 provides several benefits:

• Type Safety: Index<Foo> is a different type from Index<Bar>. This prevents accidentally using an index from a pool of Foos to access a pool of Bars. The PhantomData<T> marker enforces this at compile time with zero runtime cost.
• “None” State: The maximum value of u32 is reserved for Index::NONE, creating a clear, efficient “null” or “invalid” state, similar to Option<T> but without the added size overhead.
• API Clarity: Using Index<T> in function signatures makes it clear that the function expects a handle to a list element, not just an arbitrary number.

Implementations

impl<T> Index<T>

pub const NONE: Self

An invalid index, conceptually similar to Option::None.

This constant value (u32::MAX) is reserved to represent a null or sentinel link. All valid indices into the ElemPool will be less than this value.

pub fn is_some(&self) -> bool

Returns true if the index is valid (i.e., not Index::NONE).

Example

let valid_index = Index::<i32>::from(10_u32);
assert!(valid_index.is_some());

let invalid_index = Index::<i32>::NONE;
assert!(!invalid_index.is_some());

pub fn is_none(&self) -> bool

Returns true if the index is invalid (i.e., it is Index::NONE).

Example

let invalid_index = Index::<i32>::NONE;
assert!(invalid_index.is_none());

let valid_index = Index::<i32>::from(10_u32);
assert!(!valid_index.is_none());

Trait Implementations

impl<T> Clone for Index<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Index<T>

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

Formats the value using the given formatter.

impl<T> Default for Index<T>

fn default() -> Self

The default Index is Index::NONE.

impl<T> Display for Index<T>

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

Formats the value using the given formatter.

impl<T> From<u32> for Index<T>

fn from(ndx: u32) -> Index<T>

Creates an Index from a raw u32.

impl<T> From<usize> for Index<T>

fn from(index: usize) -> Index<T>

Creates an Index from a usize.

This conversion is fallible. Values greater than or equal to u32::MAX will be converted into an invalid index (Index::NONE). This prevents out-of-bounds errors when converting from usize on 64-bit platforms.

Example

let index1 = Index::<char>::from(123_usize);
assert!(index1.is_some());

let index2 = Index::<char>::from(u32::MAX as usize);
assert!(index2.is_none());

impl<T> Hash for Index<T>

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<T> PartialEq for Index<T>

fn eq(&self, other: &Self) -> 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<T> Copy for Index<T>

impl<T: Eq> Eq for Index<T>