std::cell::UnsafeCell

Struct std::cell::UnsafeCell

#[lang = "unsafe_cell"]
pub struct UnsafeCell<T> where    T: ?Sized,  { /* fields omitted */ }

The core primitive for interior mutability in Rust.

UnsafeCell<T> is a type that wraps some T and indicates unsafe interior operations on the wrapped type. Types with an UnsafeCell<T> field are considered to have an 'unsafe interior'. The UnsafeCell<T> type is the only legal way to obtain aliasable data that is considered mutable. In general, transmuting an &T type into an &mut T is considered undefined behavior.

The compiler makes optimizations based on the knowledge that &T is not mutably aliased or mutated, and that &mut T is unique. When building abstractions like Cell, RefCell, Mutex, etc, you need to turn these optimizations off. UnsafeCell is the only legal way to do this. When UnsafeCell<T> is immutably aliased, it is still safe to obtain a mutable reference to its interior and/or to mutate it. However, it is up to the abstraction designer to ensure that no two mutable references obtained this way are active at the same time, and that there are no active mutable references or mutations when an immutable reference is obtained from the cell. This is often done via runtime checks.

Note that while mutating or mutably aliasing the contents of an & UnsafeCell<T> is okay (provided you enforce the invariants some other way); it is still undefined behavior to have multiple &mut UnsafeCell<T> aliases.

Types like Cell<T> and RefCell<T> use this type to wrap their internal data.

Examples

use std::cell::UnsafeCell;
use std::marker::Sync;

struct NotThreadSafe<T> {
    value: UnsafeCell<T>,
}

unsafe impl<T> Sync for NotThreadSafe<T> {}

Methods

impl<T> UnsafeCell<T> [src]

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

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

unsafe fn into_inner(self) -> T

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

let five = unsafe { uc.into_inner() };

impl<T> UnsafeCell<T> where
    T: ?Sized,  [src]

fn get(&self) -> *mut T

use std::cell::UnsafeCell;

let uc = UnsafeCell::new(5);

let five = uc.get();

Trait Implementations

impl<T> Default for UnsafeCell<T> where
    T: Default, 

1.9.0

[src]

fn default() -> UnsafeCell<T>

impl<T, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> where
    T: CoerceUnsized<U>,  [src]

impl<T> Debug for UnsafeCell<T> where
    T: Debug + ?Sized, 

1.9.0

[src]

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

impl<T> !Sync for UnsafeCell<T> where
    T: ?Sized,  [src]

impl<T> From<T> for UnsafeCell<T>

1.12.0

[src]

fn from(t: T) -> UnsafeCell<T>

impl<T: ?Sized> !RefUnwindSafe for UnsafeCell<T>

1.9.0

[src]