Struct `Cell`

struct Cell<T: ?Sized> { ... }

A mutable memory location.

Memory layout

Cell<T> has the same memory layout and caveats as UnsafeCell<T>. In particular, this means that Cell<T> has the same in-memory representation as its inner type T.

Examples

In this example, you can see that Cell<T> enables mutation inside an immutable struct. In other words, it enables "interior mutability".

use std::cell::Cell;

struct SomeStruct {
    regular_field: u8,
    special_field: Cell<u8>,
}

let my_struct = SomeStruct {
    regular_field: 0,
    special_field: Cell::new(1),
};

let new_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 mutated
my_struct.special_field.set(new_value);
assert_eq!(my_struct.special_field.get(), new_value);

See the module-level documentation for more.

Implementations

`impl<T> Cell<T>`

const fn new(value: T) -> Cell<T>

Creates a new Cell containing the given value.

Examples

use std::cell::Cell;

let c = Cell::new(5);

const fn set(self: &Self, val: T) where T:

Sets the contained value.

Examples

use std::cell::Cell;

let c = Cell::new(5);

c.set(10);

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

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());

const fn replace(self: &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);

const fn into_inner(self: Self) -> T

Unwraps the value, consuming the cell.

Examples

use std::cell::Cell;

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

assert_eq!(five, 5);

`impl<T> Cell<[T]>`

const fn as_slice_of_cells(self: &Self) -> &[Cell<T>]

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

Examples

use std::cell::Cell;

let slice: &mut [i32] = &mut [1, 2, 3];
let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);
let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();

assert_eq!(slice_cell.len(), 3);

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

const fn as_array_of_cells(self: &Self) -> &[Cell<T>; N]

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

Examples

use std::cell::Cell;

let mut array: [i32; 3] = [1, 2, 3];
let cell_array: &Cell<[i32; 3]> = Cell::from_mut(&mut array);
let array_cell: &[Cell<i32>; 3] = cell_array.as_array_of_cells();

`impl<T: ?Sized> Cell<T>`

const fn as_ptr(self: &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();

const fn get_mut(self: &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);

const fn from_mut(t: &mut T) -> &Cell<T>

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

Examples

use std::cell::Cell;

let slice: &mut [i32] = &mut [1, 2, 3];
let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);
let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();

assert_eq!(slice_cell.len(), 3);

`impl<T: CloneFromCell> Cell<T>`

fn get_cloned(self: &Self) -> Self

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

This allows a cheaply Clone-able type like an Rc to be stored in a Cell, exposing the cheaper clone() method.

Examples

#![feature(cell_get_cloned)]

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

let rc = Rc::new(1usize);
let c1 = Cell::new(rc);
let c2 = c1.get_cloned();
assert_eq!(*c2.into_inner(), 1);

`impl<T: Copy> Cell<T>`

const fn get(self: &Self) -> T

Returns a copy of the contained value.

Examples

use std::cell::Cell;

let c = Cell::new(5);

let five = c.get();

const fn update<impl [const] FnOnce(T) -> T: ~const FnOnce(T) -> T>(self: &Self, f: impl ~const FnOnce(T) -> T) where T:

Updates the contained value using a function.

Examples

use std::cell::Cell;

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

`impl<T: Default> Cell<T>`

const fn take(self: &Self) -> T where T: ~const Default

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);

`impl<T> Any for Cell<T>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Cell<T>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Cell<T>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Cell<T>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> Freeze for Cell<T>`

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

fn from(t: T) -> T: Returns the argument unchanged.

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

fn from(t: never) -> T

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

fn from(t: T) -> Cell<T>: Creates a new Cell<T> containing the given value.

`impl<T> RefUnwindSafe for Cell<T>`

`impl<T> Send for Cell<T>`

`impl<T> Unpin for Cell<T>`

`impl<T> UnwindSafe for Cell<T>`

`impl<T, U> Into for Cell<T>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Cell<T>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Cell<T>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<T: ?Sized> PinCoerceUnsized for Cell<T>`

`impl<T: ?Sized> Sync for Cell<T>`

`impl<T: CoerceUnsized<U>, U> CoerceUnsized for Cell<T>`

`impl<T: Copy + Debug> Debug for crate::cell::Cell<T>`

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

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

fn clone(self: &Self) -> Cell<T>

`impl<T: DispatchFromDyn<U>, U> DispatchFromDyn for Cell<T>`

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

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

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

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

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

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

fn partial_cmp(self: &Self, other: &Cell<T>) -> Option<Ordering>
fn lt(self: &Self, other: &Cell<T>) -> bool
fn le(self: &Self, other: &Cell<T>) -> bool
fn gt(self: &Self, other: &Cell<T>) -> bool
fn ge(self: &Self, other: &Cell<T>) -> bool

`impl<T: ~const Default> Default for Cell<T>`

fn default() -> Cell<T>: Creates a Cell<T>, with the Default value for T.