Struct CellOptionRef

pub struct CellOptionRef<T: ?Sized> { /* private fields */ }

A Cell that stores option immutable references.

Examples

use stack_cell_ref::CellOptionRef;

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

Implementations

impl<T: ?Sized> CellOptionRef<T>

pub const fn new() -> Self

Creates a new CellOptionRef containing None.

Examples

use stack_cell_ref::CellOptionRef;

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

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

Returns the contained pointer.

Examples

use stack_cell_ref::CellOptionRef;

let c = CellOptionRef::<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::CellOptionRef;

let cell = CellOptionRef::new();
let foo = 1;
cell.with(Some(&foo), || {
    cell.read(|r| {
        assert_eq!(*r.unwrap(), 1);
        // ...
    });
});

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

Set the cell pointer then run fn.

Examples

use std::ptr::NonNull;

use stack_cell_ref::CellOptionRef;

let cell = CellOptionRef::new();
let foo = 1;
cell.with(Some(&foo), || {
    assert_eq!(cell.get_ptr(), Some(NonNull::from(&foo)));
    // ...
});
assert_eq!(cell.get_ptr(), None);

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T: ?Sized> Default for CellOptionRef<T>

fn default() -> Self

Returns the “default value” for a type.

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