Struct outref::OutBuf

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

A write-only slice of T.

Implementations

impl<'a, T> OutBuf<'a, T>

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

Forms an OutBuf<'a, T>

Safety

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

• data must be valid for writes 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.
  • 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 NonNull::dangling().

• data must point to len consecutive places for type T.

• The memory referenced by the returned slice must not be accessed through any other pointer (not derived from the return value) for the duration of lifetime 'a. Both read and write accesses are forbidden.

• 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.

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

Forms an OutBuf from an initialized slice.

pub fn uninit(slice: &'a mut [MaybeUninit<T>]) -> Self

Forms an OutBuf from an uninitialized slice.

pub const fn is_empty(&self) -> bool

Returns true if the buffer has a length of 0.

pub const fn len(&self) -> usize

Returns the number of elements in the buffer.

pub fn as_mut_ptr(&mut self) -> *mut T

Returns an unsafe mutable pointer to the buffer.

Trait Implementations

impl<T: Send> Send for OutBuf<'_, T>

impl<T: Sync> Sync for OutBuf<'_, T>