Struct clone_cell::cell::Cell

source ·

#[repr(transparent)]
pub struct Cell<T>where
    T: ?Sized,{ /* private fields */ }

Expand description

A mutable memory location with a get method that works with PureClone types.

Examples

Cell works with some non-Copy types such as Rc:

use std::rc::Rc;
use clone_cell::cell::Cell;

let x = Cell::new(Rc::new(0));
x.set(Rc::new(42));
assert_eq!(*x.get(), 42);

Implementations§

source §

impl<T> Cell<T>

source

pub const fn new(value: T) -> Self

Creates a new Cell containing the given value.

Examples

use clone_cell::cell::Cell;

let c = Cell::new(42);

source

pub fn set(&self, value: T)

Sets the contained value.

Examples

use clone_cell::cell::Cell;

let c = Cell::new(42);
c.set(0);

source

pub fn swap(&self, other: &Self)

Swaps the values of two Cells. Unlike std::mem::swap, this does not require a &mut reference.

Examples

use std::rc::Rc;
use clone_cell::cell::Cell;

let c1 = Cell::new(Rc::new(21));
let c2 = Cell::new(Rc::new(42));
c1.swap(&c2);
assert_eq!(42, *c1.get());
assert_eq!(21, *c2.get());

source

pub fn replace(&self, value: T) -> T

Replaces the contained value with value and returns the old value.

Examples

use std::rc::Rc;
use clone_cell::cell::Cell;

let c = Cell::new(Rc::new(42));
assert_eq!(*c.get(), 42);
assert_eq!(*c.replace(Rc::new(2)), 42);
assert_eq!(*c.get(), 2);

source

pub fn into_inner(self) -> T

Unwraps the value.

Examples

use clone_cell::cell::Cell;

let c = Cell::new(42);
assert_eq!(c.into_inner(), 42);

source

pub fn get(&self) -> Twhere
T: PureClone,

Returns a copy of the contained value.

Examples

use std::rc::Rc;
use clone_cell::cell::Cell;

let p = Rc::new(42);
let c = Cell::new(Rc::downgrade(&p));
let p2 = c.get().upgrade().unwrap();
assert_eq!(*p, *p2);
assert_eq!(p, p2);
assert_eq!(Rc::strong_count(&p), 2);
assert_eq!(Rc::strong_count(&p2), 2);

source

pub fn take(&self) -> Twhere
T: Default,

Takes the value of the Cell, leaving a Default::default() in its place.

Examples

use clone_cell::cell::Cell;

let c = Cell::new(42);
let i = c.take();
assert_eq!(i, 42);
assert_eq!(c.into_inner(), 0);

source §

impl<T> Cell<T>where
T: ?Sized,

source

pub const fn as_ptr(&self) -> *mut T

Returns a raw pointer to the underlying data in this Cell.

Examples

use clone_cell::cell::Cell;

let c = Cell::new(42);
let p = c.as_ptr();

source

pub fn get_mut(&mut self) -> &mut T

Returns a mutable reference to the underlying data. This method requires &mut self, ensuring the caller has the only reference to it.

Examples

use clone_cell::cell::Cell;

let mut c = Cell::new(42);
*c.get_mut() += 1;
assert_eq!(c.get(), 43);

source

pub fn from_mut(t: &mut T) -> &Self

Returns a &Cell<T> from a &mut T.

Examples

use std::rc::Rc;
use clone_cell::cell::Cell;

let p = &mut Rc::new(42);
let c = Cell::from_mut(p);
assert_eq!(*c.get(), 42);

source §

impl<T> Cell<[T]>

source

pub fn as_slice_of_cells(&self) -> &[Cell<T>]

Returns a &[Cell<T>] from a &Cell<[T]>.

Examples

use std::rc::Rc;
use clone_cell::cell::Cell;

let s: &mut [Rc<i32>] = &mut [Rc::new(0), Rc::new(1), Rc::new(2)];
let cs: &Cell<[Rc<i32>]> = Cell::from_mut(s);
let sc: &[Cell<Rc<i32>>] = cs.as_slice_of_cells();
assert_eq!(sc.len(), 3);
assert_eq!(*sc[0].get(), 0);
assert_eq!(*sc[1].get(), 1);
assert_eq!(*sc[2].get(), 2);