Struct Cell

pub struct Cell<T>(/* private fields */);

A Cell type with methods for by-reference mutation and inspection.

Implementations

impl<T> Cell<T>

pub fn new(value: T) -> Self

Creates a new Cell with the given value.

impl<T: Copy> Cell<T>

pub fn get(&self) -> T

Gets the value held by the cell.

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

where F: FnOnce(&T) -> R,

Calls f with a reference to the contents of the cell.

pub fn with_mut<F, R>(&self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Calls f with a mutable reference to the contents of the cell.

Methods from Deref<Target = StdCell<T>>

pub fn set(&self, val: T)

Sets the contained value.

Examples

use std::cell::Cell;

let c = Cell::new(5);

c.set(10);

pub fn swap(&self, other: &Cell<T>)

Swaps the values of two Cells.

The difference with std::mem::swap is that this function doesn’t require a &mut reference.

Panics

This function will panic if self and other are different Cells that partially overlap. (Using just standard library methods, it is impossible to create such partially overlapping Cells. However, unsafe code is allowed to e.g. create two &Cell<[i32; 2]> that partially overlap.)

Examples

use std::cell::Cell;

let c1 = Cell::new(5i32);
let c2 = Cell::new(10i32);
c1.swap(&c2);
assert_eq!(10, c1.get());
assert_eq!(5, c2.get());

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

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

Examples

use std::cell::Cell;

let cell = Cell::new(5);
assert_eq!(cell.get(), 5);
assert_eq!(cell.replace(10), 5);
assert_eq!(cell.get(), 10);

pub fn get(&self) -> T

Returns a copy of the contained value.

Examples

use std::cell::Cell;

let c = Cell::new(5);

let five = c.get();

pub fn update(&self, f: impl FnOnce(T) -> T)

🔬This is a nightly-only experimental API. (cell_update)

Updates the contained value using a function.

Examples

#![feature(cell_update)]

use std::cell::Cell;

let c = Cell::new(5);
c.update(|x| x + 1);
assert_eq!(c.get(), 6);

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

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

Examples

use std::cell::Cell;

let c = Cell::new(5);

let ptr = c.as_ptr();

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

Returns a mutable reference to the underlying data.

This call borrows Cell mutably (at compile-time) which guarantees that we possess the only reference.

However be cautious: this method expects self to be mutable, which is generally not the case when using a Cell. If you require interior mutability by reference, consider using RefCell which provides run-time checked mutable borrows through its borrow_mut method.

Examples

use std::cell::Cell;

let mut c = Cell::new(5);
*c.get_mut() += 1;

assert_eq!(c.get(), 6);

pub fn take(&self) -> T

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

Examples

use std::cell::Cell;

let c = Cell::new(5);
let five = c.take();

assert_eq!(five, 5);
assert_eq!(c.into_inner(), 0);

Trait Implementations

impl<T> CellExt<T> for Cell<T>

fn get(&self) -> T

where T: Clone + Default,

Gets the value held by the cell.

fn with<F, R>(&self, f: F) -> R

where T: Default, F: FnOnce(&T) -> R,

Calls f with a reference to the contents of the cell.

fn with_mut<F, R>(&self, f: F) -> R

where T: Default, F: FnOnce(&mut T) -> R,

Calls f with a mutable reference to the contents of the cell.

impl<T: Copy> Clone for Cell<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy> Debug for Cell<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Cell<T>

fn default() -> Cell<T>

Returns the “default value” for a type.

impl<T> Deref for Cell<T>

type Target = Cell<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Cell<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> From<Cell<T>> for Cell<T>

fn from(cell: StdCell<T>) -> Self

Converts to this type from the input type.

impl<T> From<Cell<T>> for Cell<T>

fn from(cell: Cell<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Cell<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Ord + Copy> Ord for Cell<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + Copy> PartialEq for Cell<T>

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

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

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

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

impl<T: PartialOrd + Copy> PartialOrd for Cell<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq + Copy> Eq for Cell<T>