Struct stack_cell_ref::CellRef

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

A Cell that stores immutable references.

Examples

use stack_cell_ref::CellRef;

let cell = CellRef::new();
let foo = 1;
cell.with(&foo, || {
    cell.read(|r| {
        assert_eq!(*r.unwrap(), 1);
    });
});
assert_eq!(cell.get_ptr(), None);

Implementations

impl<T: ?Sized> CellRef<T>

pub const fn new() -> Self

Creates a new CellRef containing None.

Examples

use stack_cell_ref::CellRef;

let c = CellRef::<i32>::new();

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

Returns the contained pointer.

Examples

use stack_cell_ref::CellRef;

let c = CellRef::<i32>::new();
let none = c.get_ptr();

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

Read the cell ref.

Examples

use stack_cell_ref::CellRef;

let cell = CellRef::new();
let foo = 1;
cell.with(&foo, || {
    cell.read(|r| {
        assert_eq!(*r.unwrap(), 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();
let foo = 1;
cell.with(&foo, || {
    assert_eq!(cell.get_ptr(), Some(NonNull::from(&foo)));
    // ...
});
assert_eq!(cell.get_ptr(), None);

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: ?Sized> Default for CellRef<T>

fn default() -> Self

Returns the “default value” for a type.

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

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

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

This method 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>