std::cell

StructCell

pub struct Cell<T>where    T: ?Sized,
{/* private fields */ }

Expand description

A mutable memory location.

§Memory layout

Cell<T> has the samememory layout and caveats asUnsafeCell<T>. In particular, this means thatCell<T> has the same in-memory representation as its inner typeT.

§Examples

In this example, you can see thatCell<T> enables mutation inside animmutable struct. In other words, it enables “interior mutability”.

usestd::cell::Cell;structSomeStruct {    regular_field: u8,    special_field: Cell<u8>,}letmy_struct = SomeStruct {    regular_field:0,    special_field: Cell::new(1),};letnew_value =100;// ERROR: `my_struct` is immutable// my_struct.regular_field = new_value;// WORKS: although `my_struct` is immutable, `special_field` is a `Cell`,// which can always be mutatedmy_struct.special_field.set(new_value);assert_eq!(my_struct.special_field.get(), new_value);

See themodule-level documentation for more.

Implementations§

Source §

impl<T>Cell<T>

1.0.0 (const: 1.24.0) ·Source

pub const fnnew(value: T) ->Cell<T>

Creates a newCell containing the given value.

§Examples

usestd::cell::Cell;letc = Cell::new(5);

1.0.0 (const:unstable) ·Source

pub fnset(&self, val: T)

Sets the contained value.

§Examples

usestd::cell::Cell;letc = Cell::new(5);c.set(10);

1.17.0 ·Source

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

Swaps the values of twoCells.

The difference withstd::mem::swap is that this function doesn’trequire a&mut reference.

§Panics

This function will panic ifself andother are differentCells that partially overlap.(Using just standard library methods, it is impossible to create such partially overlappingCells.However, unsafe code is allowed to e.g. create two&Cell<[i32; 2]> that partially overlap.)

§Examples

usestd::cell::Cell;letc1 = Cell::new(5i32);letc2 = Cell::new(10i32);c1.swap(&c2);assert_eq!(10, c1.get());assert_eq!(5, c2.get());

1.17.0 (const: 1.88.0) ·Source

pub const fnreplace(&self, val: T) -> T

Replaces the contained value withval, and returns the old contained value.

§Examples

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

1.17.0 (const: 1.83.0) ·Source

pub const fninto_inner(self) -> T

Unwraps the value, consuming the cell.

§Examples

usestd::cell::Cell;letc = Cell::new(5);letfive = c.into_inner();assert_eq!(five,5);

Source §

impl<T>Cell<T>
where T:Copy,

1.0.0 (const: 1.88.0) ·Source

pub const fnget(&self) -> T

Returns a copy of the contained value.

§Examples

usestd::cell::Cell;letc = Cell::new(5);letfive = c.get();

1.88.0 (const:unstable) ·Source

pub fnupdate(&self, f: implFnOnce(T) -> T)

Updates the contained value using a function.

§Examples

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

Source §

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

1.12.0 (const: 1.32.0) ·Source

pub const fnas_ptr(&self) ->*mut T

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

§Examples

usestd::cell::Cell;letc = Cell::new(5);letptr = c.as_ptr();

1.11.0 (const: 1.88.0) ·Source

pub const fnget_mut(&mut self) ->&mut T

Returns a mutable reference to the underlying data.

This call borrowsCell mutably (at compile-time) which guaranteesthat we possess the only reference.

However be cautious: this method expectsself to be mutable, which isgenerally not the case when using aCell. If you require interiormutability by reference, consider usingRefCell which providesrun-time checked mutable borrows through itsborrow_mut method.

§Examples

usestd::cell::Cell;letmutc = Cell::new(5);*c.get_mut() +=1;assert_eq!(c.get(),6);

1.37.0 (const: 1.88.0) ·Source

pub const fnfrom_mut(t:&mut T) -> &Cell<T>

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

§Examples

usestd::cell::Cell;letslice:&mut[i32] =&mut[1,2,3];letcell_slice:&Cell<[i32]> = Cell::from_mut(slice);letslice_cell:&[Cell<i32>] = cell_slice.as_slice_of_cells();assert_eq!(slice_cell.len(),3);

Source §

impl<T>Cell<T>
where T:Default,

1.17.0 (const:unstable) ·Source

pub fntake(&self) -> T
where T:Default,

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

§Examples

usestd::cell::Cell;letc = Cell::new(5);letfive = c.take();assert_eq!(five,5);assert_eq!(c.into_inner(),0);

Source §

impl<T>Cell<[T]>

1.37.0 (const: 1.88.0) ·Source

pub const fnas_slice_of_cells(&self) -> &[Cell<T>]

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

§Examples

usestd::cell::Cell;letslice:&mut[i32] =&mut[1,2,3];letcell_slice:&Cell<[i32]> = Cell::from_mut(slice);letslice_cell:&[Cell<i32>] = cell_slice.as_slice_of_cells();assert_eq!(slice_cell.len(),3);

Source §

impl<T, const N:usize>Cell<[T; N]>

1.91.0 (const: 1.91.0) ·Source

pub const fnas_array_of_cells(&self) -> &[Cell<T>;N]

Returns a&[Cell<T>; N] from a&Cell<[T; N]>

§Examples

usestd::cell::Cell;letmutarray: [i32;3] = [1,2,3];letcell_array:&Cell<[i32;3]> = Cell::from_mut(&mutarray);letarray_cell:&[Cell<i32>;3] = cell_array.as_array_of_cells();

Source §

impl<T>Cell<T>
where T:CloneFromCell,

Source

pub fnget_cloned(&self) ->Cell<T>

🔬This is a nightly-only experimental API. (cell_get_cloned #145329)

Get a clone of theCell that contains a copy of the original value.

This allows a cheaplyClone-able type like anRc to be stored in aCell, exposing thecheaperclone() method.

§Examples

#![feature(cell_get_cloned)]usecore::cell::Cell;usestd::rc::Rc;letrc = Rc::new(1usize);letc1 = Cell::new(rc);letc2 = c1.get_cloned();assert_eq!(*c2.into_inner(),1);