Struct Id

pub struct Id<T: ?Sized + SpecId<A>, A> { /* private fields */ }

A unique identifier for an object allocated using Arena.

Id<T, A> can only be used with the specific arena from which it was created, thanks to the type parameter A, which uniquely identifies the arena.

An Id<T, A> guarantees that calling Arena::get with it will always yield a reference to the same object (bitwise identical), unless the object is explicitly mutated via a mutable reference obtained from Arena::get_mut. The object associated with this Id is guaranteed to have the same lifetime as the arena itself, meaning it remains valid as long as the arena exists.

Implementations

impl<T: ?Sized + SpecId<A>, A> Id<T, A>

pub fn to_raw_id(&self) -> RawId

Trait Implementations

impl<T: ?Sized + SpecId<A>, A> Clone for Id<T, A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: ?Sized + SpecId<A>, A> Debug for Id<T, A>

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

Formats the value using the given formatter.

impl<T: SpecId<A>, A> From<Id<T, A>> for RawId

fn from(id: Id<T, A>) -> Self

Converts to this type from the input type.

impl<T: ?Sized + SpecId<A>, A> Hash for Id<T, A>

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: ?Sized + SpecId<A>, A> Index<Id<T, A>> for Arena<A>

type Output = T

The returned type after indexing.

fn index(&self, id: Id<T, A>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: ?Sized + SpecId<A>, A> IndexMut<Id<T, A>> for Arena<A>

fn index_mut(&mut self, id: Id<T, A>) -> &mut Self::Output

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

impl<T: ?Sized + SpecId<A>, A> PartialEq for Id<T, A>

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: ?Sized + SpecId<A>, A> Copy for Id<T, A>

impl<T: ?Sized + SpecId<A>, A> Eq for Id<T, A>