Struct `BorrowedBuf`

struct BorrowedBuf<'data> { ... }

A borrowed byte buffer which is incrementally filled.

This type makes it safer to work with MaybeUninit buffers, such as to read into a buffer without having to initialize it first. It tracks the region of bytes that have been filled and whether the unfilled region was initialized.

In summary, the contents of the buffer can be visualized as:

[                capacity                ]
[ filled | unfilled (may be initialized) ]

A BorrowedBuf is created around some existing data (or capacity for data) via a unique reference (&mut). The BorrowedBuf can be configured (e.g., using clear or set_init), but cannot be directly written. To write into the buffer, use unfilled to create a BorrowedCursor. The cursor has write-only access to the unfilled portion of the buffer (you can think of it as a write-only iterator).

The lifetime 'data is a bound on the lifetime of the underlying data.

Implementations

`impl<'data> BorrowedBuf<'data>`

fn capacity(self: &Self) -> usize

Returns the total capacity of the buffer.

fn len(self: &Self) -> usize

Returns the length of the filled part of the buffer.

fn is_init(self: &Self) -> bool

Returns the length of the initialized part of the buffer.

fn filled(self: &Self) -> &[u8]

Returns a shared reference to the filled portion of the buffer.

fn filled_mut(self: &mut Self) -> &mut [u8]

Returns a mutable reference to the filled portion of the buffer.

fn into_filled(self: Self) -> &'data [u8]

Returns a shared reference to the filled portion of the buffer with its original lifetime.

fn into_filled_mut(self: Self) -> &'data mut [u8]

Returns a mutable reference to the filled portion of the buffer with its original lifetime.

fn unfilled<'this>(self: &'this mut Self) -> BorrowedCursor<'this>

Returns a cursor over the unfilled part of the buffer.

fn clear(self: &mut Self) -> &mut Self

Clears the buffer, resetting the filled region to empty.

The contents of the buffer are not modified.

unsafe fn set_init(self: &mut Self) -> &mut Self

Asserts that the unfilled part of the buffer is initialized.

Safety

All the bytes of the buffer must be initialized.

`impl Debug for BorrowedBuf<'_>`

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

`impl<'data> Freeze for BorrowedBuf<'data>`

`impl<'data> From for BorrowedBuf<'data>`

fn from(buf: &'data mut [MaybeUninit<u8>]) -> BorrowedBuf<'data>

`impl<'data> From for BorrowedBuf<'data>`

fn from(slice: &'data mut [u8]) -> BorrowedBuf<'data>

`impl<'data> From for BorrowedBuf<'data>`

fn from(buf: BorrowedCursor<'data>) -> BorrowedBuf<'data>

`impl<'data> RefUnwindSafe for BorrowedBuf<'data>`

`impl<'data> Send for BorrowedBuf<'data>`

`impl<'data> Sync for BorrowedBuf<'data>`

`impl<'data> Unpin for BorrowedBuf<'data>`

`impl<'data> UnsafeUnpin for BorrowedBuf<'data>`

`impl<'data> UnwindSafe for BorrowedBuf<'data>`

`impl<T> Any for BorrowedBuf<'data>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BorrowedBuf<'data>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for BorrowedBuf<'data>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for BorrowedBuf<'data>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for BorrowedBuf<'data>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for BorrowedBuf<'data>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for BorrowedBuf<'data>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>