Struct Seal

pub struct Seal<'a, T: ?Sized> { /* private fields */ }

A mutable reference which may not be moved or assigned.

A Seal restricts a mutable reference so that the referenced value cannot be moved or assigned unless it is Unpin and NoUndef. These properties allow the safe use of mutable archived values.

Unlike Pin, all fields of Sealed values are also sealed. There is no notion of “structural sealing” as there is structural pinning. This has the upside that a Seal can be uniformly destructured with munge, which is the recommended replacement for Pin’s map_unchecked_mut function. Also unlike Pin, Sealing a reference does not require upholding the invariant that the sealed value is dropped before its backing memory is reused. This means that creating a Seal from a mutable reference is completely safe to do.

Implementations

impl<'a, T: ?Sized> Seal<'a, T>

pub fn new(inner: &'a mut T) -> Self

Returns a new Seal wrapping the given reference.

pub fn unseal(self) -> &'a mut T

where T: NoUndef + Unpin,

Returns the underlying reference for types that implement NoUndef and Unpin.

pub fn unseal_ref(self) -> &'a T

Returns the underlying reference as shared for types that implement Portable.

pub unsafe fn unseal_unchecked(self) -> &'a mut T

Returns the underlying reference.

Safety

The returned reference may not be moved unless T is Unpin. Uninitialized bytes may not be written through the Seal.

pub fn as_mut(&mut self) -> Seal<'_, T>

Mutably reborrows the Seal.

impl<'a, T> Seal<'a, [T]>

pub fn index<I: SliceIndex<[T]>>( self, index: I, ) -> Seal<'a, <I as SliceIndex<[T]>>::Output>

Indexes the Seal.

Panics

May panic if the index is out of bounds.

Trait Implementations

impl<T: ?Sized> AsRef<T> for Seal<'_, T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: ?Sized> Deref for Seal<'_, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: NoUndef + Unpin + ?Sized> DerefMut for Seal<'_, T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: ?Sized> Destructure for Seal<'_, T>

type Underlying = T

The underlying type that is destructured.

type Destructuring = Borrow

The type of destructuring to perform.

fn underlying(&mut self) -> *mut Self::Underlying

Returns a mutable pointer to the underlying type.

impl<'a, T> IntoIterator for Seal<'a, ArchivedOption<T>>

type Item = Seal<'a, T>

The type of the elements being iterated over.

type IntoIter = Iter<Seal<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: ?Sized, U: 'a + ?Sized> Restructure<U> for Seal<'a, T>

type Restructured = Seal<'a, U>

The restructured version of this type.

unsafe fn restructure(&self, ptr: *mut U) -> Self::Restructured

Restructures a pointer to this type into the target type.