Struct moving_gc_arena::Ix

#[repr(C)]pub struct Ix<T> { /* fields omitted */ }

A raw index for a region, that should be used for internal edges.

This index is invalidated by many operations. but locations which have always been exposed exactly once by foreach_ix for each collection are guaranteed to have an index which is valid.

Furthermore, indices received from a Entry or Root/Weak are valid when retrieved.

An Ix is valid so long as no invalidating methods have been called. Borrowing rules ensure several situations in which no invalidating method can be called:

• An immutable reference to the region exists
• A mutable or immutable reference to any element of this region exists, such as those acquired via Ix::get.
• An Entry for this region exists.

If an Ix is not valid for the given region, behavior is unspecified but safe, A valid instance of T may be returned. Panics may occur with get and get_mut. If the index is valid, then it still points to the expected object.

Implementations

impl<T> Ix<T>

pub fn identifier(self) -> usize

Get an identifier for this index. It is unique amongst indices in this region, so long as they have not been invalidated.

Like the index itself, uniqueness is only guaranteed as long as the index has not been invalidated.

pub fn check_region(self, region: &Region<T>) -> Result<(), Error>

If this crate has been compiled with support for validity checking, this method will verify that an index is valid. In such cases, a result of Ok indicates that this index points to a valid location in the given region and has been updated.

Otherwise, Ok will always be returned.

pub fn get(self, region: &Region<T>) -> &T

Get the value pointd to by this index in its corresponding region.

If the region is incorrect, the behavior of this function is unspecified, and it may panic (but may also return a valid T reference). Use try_get to avoid panics.

pub fn get_mut(self, region: &mut Region<T>) -> &mut T

pub fn try_get(self, region: &Region<T>) -> Result<&T, Error>

pub fn try_get_mut(self, region: &mut Region<T>) -> Result<&mut T, Error>

pub fn weak(self, region: &Region<T>) -> Weak<T>

pub fn try_weak(self, region: &Region<T>) -> Result<Weak<T>, Error>

pub fn root(self, region: &Region<T>) -> Root<T>

pub fn try_root(self, region: &Region<T>) -> Result<Root<T>, Error>

Trait Implementations

impl<T> Clone for Ix<T>

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Ix<T>

impl<T> Debug for Ix<T>

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

Formats the value using the given formatter.

impl<T> Eq for Ix<T>

If indices are in different regions or different generations, then behavior is unspecified: this may return true, false, or panic, obeying symmetry and transitivity.

In practice, it will panic if and only if the "debug-arena" feature is active.

impl<T: 'static> HasIx<T> for Ix<T>

pub fn foreach_ix<'b, 'a: 'b, F>(&'a mut self, f: F) where
    F: FnMut(&'b mut Ix<T>), 

Expose a mutable reference to every Ix owned by this datastructure. Any Ix which is not exposed by this function will be invalidated by a garbage collection. The object which was pointed to may also have been collected.

impl<T> PartialEq<Ix<T>> for Ix<T>

pub fn eq(&self, other: &Ix<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Send for Ix<T>

impl<T> Sync for Ix<T>