Struct Buf

pub struct Buf<B> { /* private fields */ }

A byte slice wrapper providing buffer functionality.

A Buf wraps a byte slice (a type which implements AsRef<[u8]> or AsMut<[u8]>) and implements various buffer traits by keeping track of prefix, body, and suffix offsets within the byte slice.

Implementations

impl Buf<Vec<u8>>

pub fn into_inner(self) -> Vec<u8>

Extracts the contained data trimmed to the buffer’s range.

impl<B: AsRef<[u8]>> Buf<B>

pub fn new<R: RangeBounds<usize>>(buf: B, body: R) -> Buf<B>

Constructs a new Buf.

new constructs a new Buf from a buffer and a body range. The bytes within the range will be the body, the bytes before the range will be the prefix, and the bytes after the range will be the suffix.

Panics

Panics if range is out of bounds of buf, or if it is nonsensical (the end precedes the start).

pub fn buffer_view(&mut self) -> BufView<'_>

Constructs a BufView which will be a BufferView into this Buf.

impl<B: AsRef<[u8]> + AsMut<[u8]>> Buf<B>

pub fn buffer_view_mut(&mut self) -> BufViewMut<'_>

Constructs a BufViewMut which will be a BufferViewMut into this Buf.

Trait Implementations

impl<B: AsMut<[u8]>> AsMut<[u8]> for Buf<B>

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

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

impl<B: AsRef<[u8]>> AsRef<[u8]> for Buf<B>

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

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

impl<B: AsRef<[u8]>> Buffer for Buf<B>

fn parse_with_view<'a, ParseArgs, P: ParsablePacket<&'a [u8], ParseArgs>>( &'a mut self, args: ParseArgs, ) -> Result<(P, &'a [u8]), P::Error>

Like ParseBuffer::parse_with but additionally provides an un-structured view into the parsed data on successful parsing.

impl<B: Clone> Clone for Buf<B>

fn clone(&self) -> Buf<B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug> Debug for Buf<B>

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

Formats the value using the given formatter.

impl<B: AsRef<[u8]>> FragmentedBuffer for Buf<B>

fn len(&self) -> usize

Gets the total length, in bytes, of this FragmentedBuffer.

fn with_bytes<R, F>(&self, f: F) -> R

where F: for<'macro_a, 'macro_b> FnOnce(FragmentedBytes<'macro_a, 'macro_b>) -> R,

Invokes a callback on a view into this buffer’s contents as FragmentedBytes.

fn to_flattened_vec(&self) -> Vec<u8>

Returns a flattened version of this buffer, copying its contents into a Vec.

fn is_empty(&self) -> bool

Returns true if this FragmentedBuffer is empty.

impl<B: AsRef<[u8]> + AsMut<[u8]>> FragmentedBufferMut for Buf<B>

fn with_bytes_mut<R, F>(&mut self, f: F) -> R

where F: for<'macro_a, 'macro_b> FnOnce(FragmentedBytesMut<'macro_a, 'macro_b>) -> R,

Invokes a callback on a mutable view into this buffer’s contents as FragmentedBytesMut.

fn zero_range<R>(&mut self, range: R)

where R: RangeBounds<usize>,

Sets all bytes in range to zero.

fn copy_within<R: RangeBounds<usize>>(&mut self, src: R, dest: usize)

Copies elements from one part of the FragmentedBufferMut to another part of itself.

fn copy_from<B: FragmentedBuffer>(&mut self, other: &B)

Copies all the bytes from another FragmentedBuffer other into self.

impl<B: AsRef<[u8]>> GrowBuffer for Buf<B>

fn with_parts<O, F>(&self, f: F) -> O

where F: for<'a, 'b> FnOnce(&'a [u8], FragmentedBytes<'a, 'b>, &'a [u8]) -> O,

Gets a view into the parts of this GrowBuffer.

fn capacity(&self) -> usize

The capacity of the buffer.

fn prefix_len(&self) -> usize

The length of the prefix.

fn suffix_len(&self) -> usize

The length of the suffix.

fn grow_front(&mut self, n: usize)

Grows the front of the body towards Growf the buffer.

fn grow_back(&mut self, n: usize)

Grows the back of the body towards the end of the buffer.

fn reset(&mut self)

Resets the body to be equal to the entire buffer.

fn undo_parse(&mut self, meta: ParseMetadata)

Undoes the effects of a previous parse in preparation for serialization.

impl<B: AsRef<[u8]> + AsMut<[u8]>> GrowBufferMut for Buf<B>

fn with_parts_mut<O, F>(&mut self, f: F) -> O

where F: for<'a, 'b> FnOnce(&'a mut [u8], FragmentedBytesMut<'a, 'b>, &'a mut [u8]) -> O,

Gets a mutable view into the parts of this GrowBufferMut.

fn grow_front_zero(&mut self, n: usize)

Extends the front of the body towards the beginning of the buffer, zeroing the new bytes.

fn grow_back_zero(&mut self, n: usize)

Extends the back of the body towards the end of the buffer, zeroing the new bytes.

fn reset_zero(&mut self)

Resets the body to be equal to the entire buffer, zeroing the new bytes.

impl<B: AsRef<[u8]>> ParseBuffer for Buf<B>

fn parse_with<'a, ParseArgs, P: ParsablePacket<&'a [u8], ParseArgs>>( &'a mut self, args: ParseArgs, ) -> Result<P, P::Error>

Parses a packet with arguments.

fn parse<'a, P: ParsablePacket<&'a [u8], ()>>( &'a mut self, ) -> Result<P, P::Error>

Parses a packet from the body.

impl<B: AsRef<[u8]> + AsMut<[u8]>> ParseBufferMut for Buf<B>

fn parse_with_mut<'a, ParseArgs, P: ParsablePacket<&'a mut [u8], ParseArgs>>( &'a mut self, args: ParseArgs, ) -> Result<P, P::Error>

Parses a mutable packet with arguments.

fn parse_mut<'a, P: ParsablePacket<&'a mut [u8], ()>>( &'a mut self, ) -> Result<P, P::Error>

Parses a mutable packet from the body.

impl<B: AsRef<[u8]>> PartialEq for Buf<B>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<B: AsRef<[u8]>> ShrinkBuffer for Buf<B>

fn shrink<R: RangeBounds<usize>>(&mut self, range: R)

Shrinks the body.

fn shrink_front(&mut self, n: usize)

Shrinks the front of the body towards the end of the buffer.

fn shrink_back(&mut self, n: usize)

Shrinks the back of the body towards the beginning of the buffer.

fn shrink_front_to(&mut self, len: usize)

Shrinks the buffer to be no larger than len bytes, consuming from the front.

fn shrink_back_to(&mut self, len: usize)

Shrinks the buffer to be no larger than len bytes, consuming from the back.

impl<B: AsRef<[u8]>> ContiguousBuffer for Buf<B>

impl<B: AsRef<[u8]>> Eq for Buf<B>