Struct VolatileWriteOnlySlice

pub struct VolatileWriteOnlySlice<'a, T: 'a> { /* private fields */ }

A write-only slice with non-dropping volatile write access.

Implementations

impl<'a, T: 'a> VolatileWriteOnlySlice<'a, T>

pub unsafe fn from_raw_parts(data: *mut T, len: usize) -> Self

Forms a write-only slice from a pointer and a length.

The len argument is the number of elements, not the number of bytes.

Safety

Behavior is undefined if any of the following conditions are violated:

• data must be valid for reads for len * mem::size_of::<T>() many bytes, and it must be properly aligned. This means in particular:

  • The entire memory range of this slice must be contained within a single allocated object! Slices can never span across multiple allocated objects. See below for an example incorrectly not taking this into account.
  • data must be non-null and aligned even for zero-length slices. One reason for this is that enum layout optimizations may rely on references (including slices of any length) being aligned and non-null to distinguish them from other data. You can obtain a pointer that is usable as data for zero-length slices using ::core::ptr::NonNull::dangling().

• data must point to len consecutive properly initialized values of type T.

• The memory referenced by the returned slice must not be mutated for the duration of lifetime 'a, except inside an UnsafeCell.

• The total size len * mem::size_of::<T>() of the slice must be no larger than isize::MAX. See the safety documentation of pointer::offset.

Caveat

The lifetime for the returned slice is inferred from its usage. To prevent accidental misuse, it’s suggested to tie the lifetime to whichever source lifetime is safe in the context, such as by providing a helper function taking the lifetime of a host value for the slice, or by explicit annotation.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl<'a, T: 'a> From<&'a mut [T]> for VolatileWriteOnlySlice<'a, T>

fn from(slice: &'a mut [T]) -> Self

Converts to this type from the input type.

impl<'a, T: 'a> WriteAt<T> for VolatileWriteOnlySlice<'a, T>

fn write_at(&mut self, index: usize, value: T)

Performs a write of a memory location with the given value without reading or dropping the old value.

unsafe fn write_at_unchecked(&mut self, index: usize, value: T)

Performs a write of a memory location with the given value without reading or dropping the old value.

impl<'a, T: 'a> WriteFromSliceAt<T> for VolatileWriteOnlySlice<'a, T>

fn write_cloning_from_slice_at(&mut self, src: &[T], offset: usize)

where T: Clone,

Copies the elements from src into self.

fn write_copying_from_slice_at(&mut self, src: &[T], offset: usize)

where T: Copy,

Copies all elements from src into self, using a memcpy.