Struct uninit_tools::buffer::Buffer

pub struct Buffer<T> { /* fields omitted */ }

Implementations

impl<T> Buffer<T>

pub const fn from_initializer(initializer: BufferInitializer<T>) -> Self

Create a new buffer from an initializer.

pub const fn uninit(inner: T) -> Self

Create a new buffer, defaulting to not being initialized, nor filled. Prefer new if the buffer is already initialized.

pub fn into_raw_parts(self) -> (BufferInitializer<T>, usize)

Move out the buffer initializer, which contains the inner buffer and initialization cursor, and get the filledness cursor.

pub fn into_initializer(self) -> BufferInitializer<T>

pub fn into_inner(self) -> T

Move out the inner buffer, being uninitialized or initialized based on whatever it was when this buffer was constructed.

Use try_into_init if the buffer is initialized.

pub const fn items_filled(&self) -> usize

Get the number of items that are currently filled, within the buffer. Note that this is different from the number of initialized items; use items_initialized for that.

pub fn by_ref(&mut self) -> BufferRef<'_, T>

pub const fn initializer(&self) -> &BufferInitializer<T>

pub fn initializer_mut(&mut self) -> &mut BufferInitializer<T>

impl<T, Item> Buffer<AsUninit<T>> where
    T: Deref<Target = [Item]> + DerefMut + TrustedDeref, 

pub fn new(init: T) -> Self

impl<T> Buffer<T> where
    T: Initialize, 

pub fn capacity(&self) -> usize

pub fn remaining(&self) -> usize

Get the number of items that may be filled before the buffer is full.

pub fn is_full(&self) -> bool

Check whether the buffer is completely filled, and thus also initialized.

pub fn is_empty(&self) -> bool

Check whether the buffer is empty. It can be partially or fully initialized however.

pub fn filled_part(&self) -> &[T::Item]

Retrieve a shared slice to the filled part of the buffer.

pub fn filled_part_mut(&mut self) -> &mut [T::Item]

Retrieve a mutable slice to the filled part of the buffer.

pub fn unfilled_part(&self) -> &[MaybeUninit<T::Item>]

Get a shared slice to the unfilled part, which may be uninitialized.

pub unsafe fn unfilled_part_mut(&mut self) -> &mut [MaybeUninit<T::Item>]

Get a mutable reference to the unfilled part of the buffer, which may overlap with the initialized-but-nonfilled region.

Safety

Due to the possibility of an overlap between the part that is initialized and the part that is unfilled, the caller must ensure that the resulting slice is never used to deinitialize the buffer.

It is thus recommended to use append or fill_by_repeating instead, since those are the by far most common operations to do when initializing. However, code that requires interfacing with other APIs such as system calls, need to use this function.

If mutable access really is needed for the unfilled region in safe code, consider using all_parts_mut.

pub fn filled_unfilled_parts(&self) -> (&[T::Item], &[MaybeUninit<T::Item>])

Borrow both the filled and unfilled parts immutably.

pub fn all_parts(&self) -> BufferParts<'_, T::Item>

Borrow the filled part, the unfilled but initialized part, and the unfilled and uninitialized part.

pub fn all_parts_mut(&mut self) -> BufferPartsMut<'_, T::Item>

pub unsafe fn filled_unfilled_parts_mut(
    &mut self
) -> (&mut [T::Item], &mut [MaybeUninit<T::Item>])

Borrow both the filled and the unfilled parts, mutably.

Safety

This is unsafe as the uninit part may have items in it that are tracked to be initialized. It is hence the responsibility of the caller to ensure that the buffer is not deinitialized by writing MaybeUninit::uninit() to it.

pub fn unfilled_init_part(&self) -> &[T::Item]

pub fn unfilled_init_part_mut(&mut self) -> &mut [T::Item]

Get the initialized part of the unfilled part, if there is any.

pub fn unfilled_uninit_part(&self) -> &[MaybeUninit<T::Item>]

pub fn unfilled_uninit_part_mut(&mut self) -> &mut [MaybeUninit<T::Item>]

Get the uninitialized part of the unfilled part, if there is any.

pub fn unfilled_parts(&mut self) -> (&[T::Item], &[MaybeUninit<T::Item>])

pub fn unfilled_parts_mut(
    &mut self
) -> (&mut [T::Item], &mut [MaybeUninit<T::Item>])

pub fn revert_to_start(&mut self)

Revert the internal cursor to 0, forgetting about the initialized items.

pub fn append(&mut self, slice: &[T::Item]) where
    T::Item: Copy, 

pub fn advance(&mut self, count: usize)

pub fn advance_to_init_part(&mut self)

pub unsafe fn assume_init(&mut self, count: usize)

Increment the counter that marks the progress of filling, as well as the initialization progress, count items.

Safety

This does not initialize nor fill anything, and it is hence up to the user to ensure that no uninitialized items are marked initialized.

pub unsafe fn assume_init_all(&mut self)

Mark the buffer as fully filled and initialized, without actually filling the buffer.

Safety

For this to be safe, the caller must ensure that every single item in the slice that the buffer wraps, is initialized.

pub fn fill_by_repeating(&mut self, item: T::Item) where
    T::Item: Copy, 

impl<T> Buffer<T> where
    T: Initialize<Item = u8>, 

pub fn fill_by_zeroing(&mut self)

impl<'a> Buffer<AsUninit<&'a mut [u8]>>

pub fn from_slice_mut(slice: &'a mut [u8]) -> Self

impl<'a> Buffer<&'a mut [MaybeUninit<u8>]>

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

Trait Implementations

impl<T> Debug for Buffer<T> where
    T: Initialize, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.