Struct rlifesrc_lib::cells::CellRef

#[repr(transparent)]
pub struct CellRef<R: Rule> {
    cell: NonNull<LifeCell<R>>,
}

A reference to a LifeCell. It is just a wrapped NonNull pointer.

Safety

This type is just a wrapped raw pointer. Dereferring a CellRef should follow the same guarantees for dereferring a raw mut pointer.

Furthermore, a CellRef referring to a cell in one world should never be used in any function or method involving another world.

Fields

cell: NonNull<LifeCell<R>>

The LifeCell it refers to.

Implementations

impl<R: Rule> CellRef<R>

pub(crate) const unsafe fn new(ptr: *mut LifeCell<R>) -> Self

Creates a new CellRef from a mut pointer to a LifeCell.

Methods from Deref<Target = LifeCell<R>>

pub(crate) fn update_desc(&self, state: State, new: bool)

Updates the neighborhood descriptors of all neighbors and the predecessor when the state of one cell is changed.

Here state is the new state of the cell when new is true, the old state when new is false.

Trait Implementations

impl<R: Rule> Clone for CellRef<R>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Rule> Debug for CellRef<R>

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

Formats the value using the given formatter.

impl<R: Rule> Deref for CellRef<R>

type Target = LifeCell<R>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<R: Rule> Hash for CellRef<R>

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<R: Rule> PartialEq for CellRef<R>

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Rule> Copy for CellRef<R>

impl<R: Rule> Eq for CellRef<R>