Struct write_only::WriteOnlySlice

pub struct WriteOnlySlice<'a, T: 'a> { /* fields omitted */ }

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

Implementations

impl<'a, T: 'a> WriteOnlySlice<'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 items 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 WriteOnlySlice<'a, T>

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

Performs the conversion.

impl<'a, T: 'a> PutAt<T> for WriteOnlySlice<'a, T>

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

Puts the value at index to the given value, dropping the old value.

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

Puts the value at index to the given value, dropping the old value without checking bounds.

impl<'a, T: 'a> PutFromSliceAt<T> for WriteOnlySlice<'a, T>

fn put_cloning_from_slice_at(&mut self, src: &[T], offset: usize) where
    T: Clone, 

Clones the elements from src into self, starting at offset, dropping the old values.

impl<'a, T: 'a> WriteAt<T> for WriteOnlySlice<'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 WriteOnlySlice<'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.