Struct packet::serialize::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]>> GrowBuffer for Buf<B>

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 the beginning of 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]>> 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<Buf<B>> for Buf<B>

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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]> + AsMut<[u8]>> TargetBuffer for Buf<B>

fn with_parts<O, F>(&mut self, f: F) -> Owhere F: for<'a, 'b> FnOnce(&'a mut [u8], FragmentedBytesMut<'a, 'b>, &'a mut [u8]) -> O,

Gets a view into the parts of this TargetBuffer.

fn serialize<B: PacketBuilder>(&mut self, c: PacketConstraints, builder: B)

Serializes a packet in the buffer.

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

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

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