Trait ParseBufferMut

pub trait ParseBufferMut: ParseBuffer + ContiguousBufferMut {
    // Required method
    fn parse_with_mut<'a, ParseArgs, P: ParsablePacket<&'a mut [u8], ParseArgs>>(
        &'a mut self,
        args: ParseArgs,
    ) -> Result<P, P::Error>;

    // Provided method
    fn parse_mut<'a, P: ParsablePacket<&'a mut [u8], ()>>(
        &'a mut self,
    ) -> Result<P, P::Error> { ... }
}

A ParseBuffer which provides mutable access to its contents.

While a ParseBuffer allows the ranges covered by its prefix, body, and suffix to be modified, it only provides immutable access to their contents. A ParseBufferMut, on the other hand, provides mutable access to the contents of its prefix, body, and suffix.

Notable implementations

ParseBufferMut is implemented for mutable byte slices - &mut [u8]. Mutable byte slices do not implement GrowBuffer or GrowBufferMut; once bytes are consumed from their bodies, those bytes are discarded and cannot be recovered.

Required Methods

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.

parse_with_mut is like parse_mut, but it accepts arguments to pass to P::parse_mut.

Provided Methods

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

Parses a mutable packet from the body.

parse_mut is like ParseBuffer::parse, but instead of calling P::parse on a BufferView, it calls P::parse_mut on a BufferViewMut. The effect is that the parsed packet can contain mutable references to the buffer. This can be useful if you want to modify parsed packets in-place.

Depending on the implementation of P::parse_mut, the contents of the buffer may be modified during parsing.

See the BufferViewMut and ParsablePacket documentation for more details.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> ParseBufferMut for &'a mut [u8]

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

Implementors

impl ParseBufferMut for EmptyBuf

impl<A, B> ParseBufferMut for Either<A, B>

where A: ParseBufferMut, B: ParseBufferMut,

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