Struct CellRef

pub struct CellRef<T: ?Sized>(/* private fields */);

A Cell that stores immutable references.

Examples

use stack_cell_ref::CellRef;

let cell = CellRef::new_with(&0);
let foo = 1;
cell.with(&foo, || {
    cell.read(|r| {
        assert_eq!(*r, 1);
    });
});
assert_eq!(unsafe { *cell.get_ptr().as_ref() }, 0);

Implementations

impl<T: ?Sized> CellRef<T>

pub const fn new_with(r: &T) -> Self

Creates a new CellRef containing None.

Examples

use stack_cell_ref::CellRef;

let c = CellRef::<i32>::new_with(&0);

pub fn get_ptr(&self) -> NonNull<T>

Returns the contained pointer.

Examples

use stack_cell_ref::CellRef;

let c = CellRef::<i32>::new_with(&0);
let ptr_to_zero = c.get_ptr();

pub fn read<F: FnOnce(&T) -> R, R>(&self, f: F) -> R

Read the cell ref.

Examples

use stack_cell_ref::CellRef;

let cell = CellRef::new_with(&0);
let foo = 1;
cell.with(&foo, || {
    cell.read(|r| {
        assert_eq!(*r, 1);
        // ...
    });
});

pub fn with<F: FnOnce() -> R, R>(&self, r: &T, f: F) -> R

Set the cell pointer then run fn.

Examples

use std::ptr::NonNull;

use stack_cell_ref::CellRef;

let cell = CellRef::new_with(&0);
let foo = 1;
cell.with(&foo, || {
    assert_eq!(cell.get_ptr(), NonNull::from(&foo));
    // ...
});
assert_eq!(unsafe { *cell.get_ptr().as_ref() }, 0);

Trait Implementations

impl<T: Debug + ?Sized> Debug for CellRef<T>

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

Formats the value using the given formatter.

impl<T: Hash + ?Sized> Hash for CellRef<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 + ?Sized> PartialEq for CellRef<T>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq + ?Sized> Eq for CellRef<T>