Struct Buffer

pub struct Buffer<T: Sized> { /* private fields */ }

Static buffer to raw bytes

The size of the storage must be known at compile time, therefore it is suitable only for non-dynamic storages.

While write semantics are pretty obvious, read behaviour is more complicated due to it being a static buffer.

When performing ReadBuf::read memory is always being read from the beginning. So as with any other implementation read leads to consumption. But as this buffer is single chunk of static memory, such operation will require to shift already written bytes to the beginning (meaning each ReadBuf::consume involves a memmove unless consumed len is not equal to current len)

In general it would be more effective to access memory as slice and then consume it, if needed.

Implementations

impl<S: Sized> Buffer<S>

pub const fn new() -> Self

Creates new instance

pub const fn into_circular(self) -> Ring<S>

Transforms buffer into ring buffer.

pub const unsafe fn from_parts(inner: MaybeUninit<S>, cursor: usize) -> Self

Creates new instance from parts.

cursor - number of elements written. It is user responsibility to make sure it is not over actual capacity

pub const fn into_parts(self) -> (MaybeUninit<S>, usize)

Splits buffer into parts.

pub const fn as_ptr(&self) -> *const u8

Returns pointer to the beginning of underlying buffer

pub const fn remaining(&self) -> usize

Returns number of bytes left (not written yet)

pub fn as_slice(&self) -> &[u8]

Returns slice to already written data.

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns mutable slice to already written data.

pub fn truncate(&mut self, cursor: usize)

Shortens the buffer.

Does nothing if new cursor is after current position.

pub unsafe fn set_len(&mut self, cursor: usize)

Changes written length, without writing.

When used, user must guarantee that these bytes are written.

pub const fn capacity() -> usize

Returns buffer overall capacity.

pub const fn len(&self) -> usize

Returns number of bytes written.

Trait Implementations

impl<S: Sized> AsRef<[u8]> for Buffer<S>

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Sized> Buf for Buffer<S>

fn capacity(&self) -> usize

Returns size of the underlying memory in the buffer.

fn len(&self) -> usize

Returns number of elements inside the buffer.

fn iter(&self) -> Iter<'_, Self>

Returns iterator over elements inside the buffer.

fn iter_mut(&mut self) -> IterMut<'_, Self>

Returns mutable iterator over elements inside the buffer.

impl<S: Sized> ContBuf for Buffer<S>

fn as_read_slice(&self) -> &[u8]

Returns slice of bytes that can be read.

fn as_read_slice_mut(&mut self) -> &mut [u8]

Returns mutable slice of bytes that can be read.

fn as_write_slice(&mut self) -> &mut [MaybeUninit<u8>]

Returns slice of bytes that can be written (i.e. not written yet).

impl<S: Sized> Debug for Buffer<S>

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

Formats the value using the given formatter.

impl<S: Sized> Index<usize> for Buffer<S>

type Output = u8

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<S: Sized> IndexMut<usize> for Buffer<S>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<S: Sized> ReadBuf for Buffer<S>

unsafe fn consume(&mut self, step: usize)

Moves cursor, considering bytes as consumed.

unsafe fn read(&mut self, ptr: *mut u8, size: usize)

Low level read function, that consumes available bytes up to size.

fn available(&self) -> usize

Returns number of bytes left

fn read_slice(&mut self, bytes: &mut [u8]) -> usize

Reads available bytes into slice

impl<S: Sized> WriteBuf for Buffer<S>

fn remaining(&self) -> usize

Returns number of bytes left

unsafe fn advance(&mut self, step: usize)

Moves cursor, considering bytes written.

unsafe fn write(&mut self, ptr: *const u8, size: usize)

Low level write method, which copies data from pointer up to size.

fn write_slice(&mut self, bytes: &[u8]) -> usize

Writes supplied slice into the buffer, returning number of written bytes.