Trait FragmentedBufferMut

pub trait FragmentedBufferMut: FragmentedBuffer {
    // Required method
    fn with_bytes_mut<R, F>(&mut self, f: F) -> R
       where F: for<'a, 'b> FnOnce(FragmentedBytesMut<'a, 'b>) -> R;

    // Provided methods
    fn zero_range<R>(&mut self, range: R)
       where R: RangeBounds<usize> { ... }
    fn copy_within<R: RangeBounds<usize>>(&mut self, src: R, dst: usize) { ... }
    fn copy_from<B: FragmentedBuffer>(&mut self, other: &B) { ... }
}

A FragmentedBuffer with mutable access to its contents.

Required Methods

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

where F: for<'a, 'b> FnOnce(FragmentedBytesMut<'a, 'b>) -> R,

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

Provided Methods

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

where R: RangeBounds<usize>,

Sets all bytes in range to zero.

Panics

Panics if the provided range is not within the bounds of this FragmentedBufferMut, or if the range is nonsensical (the end precedes the start).

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

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

src is the range within self to copy from. dst is the starting index of the range within self to copy to, which will have the same length as src. The two ranges may overlap. The ends of the two ranges must be less than or equal to self.len().

Panics

Panics if either the source or destination range is out of bounds, or if src is nonsensical (its end precedes its start).

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

Copies all the bytes from another FragmentedBuffer other into self.

Panics

Panics if self.len() != other.len().

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 FragmentedBufferMut for Infallible

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

where F: for<'a, 'b> FnOnce(FragmentedBytesMut<'a, 'b>) -> R,

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

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,

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

where R: RangeBounds<usize>,

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

Implementors

impl FragmentedBufferMut for EmptyBuf

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

where A: FragmentedBufferMut, B: FragmentedBufferMut,

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