Cell in std::cell - Rust (original) (raw)
pub struct Cell<T>
where
T: ?Sized,
{ /* private fields */ }Expand description
A mutable memory location.
§Memory layout
Cell<T> has the same memory layout and caveats asUnsafeCell. In particular, this means thatCell<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.
1.0.0 (const: 1.24.0)
Creates a new Cell containing the given value.
§Examples
use std::cell::Cell;
let c = Cell::new(5);1.0.0 (const: unstable)
Sets the contained value.
§Examples
use std::cell::Cell;
let c = Cell::new(5);
c.set(10);1.17.0
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());1.17.0 (const: 1.88.0)
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);1.17.0 (const: 1.83.0)
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);1.0.0 (const: 1.88.0)
Returns a copy of the contained value.
§Examples
use std::cell::Cell;
let c = Cell::new(5);
let five = c.get();1.88.0 (const: unstable)
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);1.12.0 (const: 1.32.0)
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();1.11.0 (const: 1.88.0)
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);1.37.0 (const: 1.88.0)
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);1.17.0 (const: unstable)
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);1.37.0 (const: 1.88.0)
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);1.91.0 (const: 1.91.0)
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();🔬This is a nightly-only experimental API. (cell_get_cloned #145329)
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);1.0.0§
Returns a duplicate of the value. Read more
1.0.0§
Performs copy-assignment from source. Read more
1.0.0§
Formats the value using the given formatter. Read more
Creates a Cell<T>, with the Default value for T.
Creates a new Cell<T> containing the given value.
1.10.0§
1.21.0§
Compares and returns the maximum of two values. Read more
1.21.0§
Compares and returns the minimum of two values. Read more
1.50.0§
Restrict a value to a certain interval. Read more
1.0.0§
Tests for self and other values to be equal, and is used by ==.
1.0.0§
Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
1.10.0§
This method returns an ordering between self and other values if one exists. Read more
Tests less than (for self and other) and is used by the < operator. Read more
Tests less than or equal to (for self and other) and is used by the<= operator. Read more
Tests greater than (for self and other) and is used by the >operator. Read more
Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
1.2.0§
1.0.0§
1.0.0§
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
🔬This is a nightly-only experimental API. (clone_to_uninit #126799)
Performs copy-assignment from self to dest. Read more
Converts to this type from the input type.
Returns the argument unchanged.
Calls U::from(self).
That is, this conversion is whatever the implementation of[From](../convert/trait.From.html "trait std::convert::From")<T> for U chooses to do.
The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.