Struct CovariantUnsafeCell 

#[repr(transparent)]
pub struct CovariantUnsafeCell<T>(UnsafeCell<T>)
where
    T: ?Sized;

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Covariant version of UnsafeCell.

Tuple Fields

0: UnsafeCell<T>

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Implementations

impl<T> CovariantUnsafeCell<T>

pub const fn new(value: T) -> CovariantUnsafeCell<T>

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Constructs a new instance of CovariantUnsafeCell which will wrap the specified value.

All access to the inner value through &CovariantUnsafeCell<T> requires unsafe code.

Examples

#![feature(covariant_unsafe_cell)]
use std::cell::CovariantUnsafeCell;

let uc = CovariantUnsafeCell::new(5);

pub const fn into_inner(self) -> T

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Unwraps the value, consuming the cell.

Examples

#![feature(covariant_unsafe_cell)]
use std::cell::CovariantUnsafeCell;

let uc = CovariantUnsafeCell::new(5);

let five = uc.into_inner();

impl<T> CovariantUnsafeCell<T>

where T: ?Sized,

pub const fn get(&self) -> NonNull<T>

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Gets a mutable non-null pointer to the wrapped value.

This can be cast to a pointer of any kind. When creating (shared or mutable) references, you must uphold the aliasing rules; see the UnsafeCell type-level docs for more discussion and caveats.

Examples

#![feature(covariant_unsafe_cell)]
use std::cell::CovariantUnsafeCell;
use std::ptr::NonNull;

let uc = CovariantUnsafeCell::new(5);

let ptr: NonNull<i32> = uc.get();

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

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Returns a mutable reference to the underlying data.

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

Examples

#![feature(covariant_unsafe_cell)]
use std::cell::CovariantUnsafeCell;

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

assert_eq!(*c.get_mut(), 6);

pub const fn raw_get(this: *const CovariantUnsafeCell<T>) -> *mut T

🔬This is a nightly-only experimental API. (covariant_unsafe_cell #159735)

Gets a mutable pointer to the wrapped value. The difference from get is that this function accepts a raw pointer, which is useful to avoid the creation of temporary references.

This can be cast to a pointer of any kind. When creating (shared or mutable) references, you must uphold the aliasing rules; see [the UnsafeCell type-level docs] for more discussion and caveats.

Examples

Gradual initialization of an CovariantUnsafeCell requires raw_get, as calling get would require creating a reference to uninitialized data:

#![feature(covariant_unsafe_cell)]
use std::cell::CovariantUnsafeCell;
use std::mem::MaybeUninit;

let m = MaybeUninit::<CovariantUnsafeCell<i32>>::uninit();
unsafe { CovariantUnsafeCell::raw_get(m.as_ptr()).write(5); }
// avoid below which references to uninitialized data
// unsafe { CovariantUnsafeCell::get(&*m.as_ptr()).write(5); }
let uc = unsafe { m.assume_init() };

assert_eq!(uc.into_inner(), 5);

Trait Implementations

impl<T> !Sync for CovariantUnsafeCell<T>

where T: ?Sized,

impl<T, U> CoerceUnsized<CovariantUnsafeCell<U>> for CovariantUnsafeCell<T>

where T: CoerceUnsized<U>,

impl<T> Debug for CovariantUnsafeCell<T>

where T: ?Sized,

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

Formats the value using the given formatter.