Struct sealingslice::SealingSlice

pub struct SealingSlice<'s, T: 's> { /* private fields */ }

A slice that can seal parts of itself off from mutability, and hand out the sealed parts as immutable references.

The slice grows immutable from start to end in a contiguous way, is initially mutable as a whole. The seal is moved forward using the .seal(n) method. The sealed and unsealed parts can be accessed with the .sealed() and .mutable() methods, respectively.

Implementations

impl<'s, T> SealingSlice<'s, T>

pub fn new(slice: &'s mut [T]) -> Self

Create a new SealingSlice. The slice is initially fully mutable.

pub fn seal(&mut self, n: usize)

Seal off n more items in the slice.

Like out-of-bounds slice access, this panics if n is less than .mutable().len() – thus ensuring that .sealed() and .mutable() will not.

pub fn mutable<'a>(&'a mut self) -> &'a mut [T]

Obtain the unsealed part of the slice. This is an immutable view on the original slice, starts at its beginning, and always as long as the sum of all previous .seal(n) arguments.

pub fn sealed<'a>(&'a self) -> &'s [T]

Obtain the sealed part of the slice. That is a mutable view on the original slice, ends at its end, and always has the length of the original slice minus the sum of all sealed parts.