internet 0.0.5

//! Abstract memory representations for zero-cost network operations.
//!
//! The `buffer` module provides the foundational [`Buf`] and [`BufMut`] traits.
//! Instead of tying protocol logic to specific data structures (like [`[u8]`], [`Vec<u8>`],
//! or custom ring buffers), these traits create an agnostic memory interface.
//!
//! This ensures the entire stack remains `no_std` compatible and completely
//! decoupled from memory allocation strategies. It gives you absolute control
//! over how and where your network packets are stored, enabling seamless integration
//! with anything from embedded static arrays to asynchronous `io_uring` buffers.

/// Errors that can occur during buffer read or write operations.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BufError {
    /// Requested offset or length is out of buffer bounds.
    OutOfBounds,
    /// Unexpected end of input while parsing.
    UnexpectedEof,
    /// Encoded data value is invalid for the target type.
    UnexpectedValue,
    /// Destination buffer is too small to complete the write.
    BufferTooSmall,
    /// Invalid length specified for a buffer operation.
    InvalidLength,
    /// Protocol-level error with a descriptive message.
    ProtocolError(&'static str),
}

impl core::error::Error for BufError {}

impl core::fmt::Display for BufError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            BufError::OutOfBounds => write!(f, "Buffer offset out of bounds"),
            BufError::UnexpectedEof => write!(f, "Unexpected end of buffer"),
            BufError::UnexpectedValue => write!(f, "Unexpected value in buffer"),
            BufError::BufferTooSmall => write!(f, "Buffer is too small"),
            BufError::InvalidLength => write!(f, "Invalid length"),
            BufError::ProtocolError(msg) => write!(f, "Protocol error: {msg}"),
        }
    }
}

/// Specialized [`Result`] type for buffer operations.
pub type BufResult<T> = core::result::Result<T, BufError>;

/// Read-only memory abstraction supporting random-access reads.
pub trait Buf {
    /// Returns the total size of the buffer in bytes.
    fn length(&self) -> usize;

    /// Returns `true` if the buffer contains no bytes.
    #[inline]
    fn is_empty(&self) -> bool {
        self.length() == 0
    }

    /// Reads a single byte at the specified `offset`.
    fn get_u8(&self, offset: usize) -> BufResult<u8>;

    /// Reads a single byte at the specified `offset` without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset < self.length()`.
    unsafe fn get_u8_unchecked(&self, offset: usize) -> u8;

    /// Reads an unsigned 16-bit integer in Big Endian format.
    #[inline]
    fn get_u16_be(&self, offset: usize) -> BufResult<u16> {
        Ok(u16::from_be_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 16-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 2 <= self.length()`.
    #[inline]
    unsafe fn get_u16_be_unchecked(&self, offset: usize) -> u16 {
        u16::from_be_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 16-bit integer in Little Endian format.
    #[inline]
    fn get_u16_le(&self, offset: usize) -> BufResult<u16> {
        Ok(u16::from_le_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 16-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 2 <= self.length()`.
    #[inline]
    unsafe fn get_u16_le_unchecked(&self, offset: usize) -> u16 {
        u16::from_le_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 32-bit integer in Big Endian format.
    #[inline]
    fn get_u32_be(&self, offset: usize) -> BufResult<u32> {
        Ok(u32::from_be_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 32-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 4 <= self.length()`.
    #[inline]
    unsafe fn get_u32_be_unchecked(&self, offset: usize) -> u32 {
        u32::from_be_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 32-bit integer in Little Endian format.
    #[inline]
    fn get_u32_le(&self, offset: usize) -> BufResult<u32> {
        Ok(u32::from_le_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 32-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 4 <= self.length()`.
    #[inline]
    unsafe fn get_u32_le_unchecked(&self, offset: usize) -> u32 {
        u32::from_le_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 64-bit integer in Big Endian format.
    #[inline]
    fn get_u64_be(&self, offset: usize) -> BufResult<u64> {
        Ok(u64::from_be_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 64-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 8 <= self.length()`.
    #[inline]
    unsafe fn get_u64_be_unchecked(&self, offset: usize) -> u64 {
        u64::from_be_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 64-bit integer in Little Endian format.
    #[inline]
    fn get_u64_le(&self, offset: usize) -> BufResult<u64> {
        Ok(u64::from_le_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 64-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 8 <= self.length()`.
    #[inline]
    unsafe fn get_u64_le_unchecked(&self, offset: usize) -> u64 {
        u64::from_le_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 128-bit integer in Big Endian format.
    #[inline]
    fn get_u128_be(&self, offset: usize) -> BufResult<u128> {
        Ok(u128::from_be_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 128-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 16 <= self.length()`.
    #[inline]
    unsafe fn get_u128_be_unchecked(&self, offset: usize) -> u128 {
        u128::from_be_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an unsigned 128-bit integer in Little Endian format.
    #[inline]
    fn get_u128_le(&self, offset: usize) -> BufResult<u128> {
        Ok(u128::from_le_bytes(self.get_array(offset)?))
    }

    /// Reads an unsigned 128-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 16 <= self.length()`.
    #[inline]
    unsafe fn get_u128_le_unchecked(&self, offset: usize) -> u128 {
        u128::from_le_bytes(unsafe { self.get_array_unchecked(offset) })
    }

    /// Reads an architecture-sized unsigned integer in Big Endian format.
    #[inline]
    fn get_usize_be(&self, offset: usize) -> BufResult<usize> {
        let bytes: [u8; core::mem::size_of::<usize>()] = self.get_array(offset)?;
        Ok(usize::from_be_bytes(bytes))
    }

    /// Reads an architecture-sized unsigned integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + core::mem::size_of::<usize>() <= self.length()`.
    #[inline]
    unsafe fn get_usize_be_unchecked(&self, offset: usize) -> usize {
        let bytes: [u8; core::mem::size_of::<usize>()] =
            unsafe { self.get_array_unchecked(offset) };
        usize::from_be_bytes(bytes)
    }

    /// Reads an architecture-sized unsigned integer in Little Endian format.
    #[inline]
    fn get_usize_le(&self, offset: usize) -> BufResult<usize> {
        let bytes: [u8; core::mem::size_of::<usize>()] = self.get_array(offset)?;
        Ok(usize::from_le_bytes(bytes))
    }

    /// Reads an architecture-sized unsigned integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + core::mem::size_of::<usize>() <= self.length()`.
    #[inline]
    unsafe fn get_usize_le_unchecked(&self, offset: usize) -> usize {
        let bytes: [u8; core::mem::size_of::<usize>()] =
            unsafe { self.get_array_unchecked(offset) };
        usize::from_le_bytes(bytes)
    }

    /// Reads a fixed-size byte array `[u8; N]` at the specified `offset`.
    #[inline]
    fn get_array<const N: usize>(&self, offset: usize) -> BufResult<[u8; N]> {
        let mut arr = [0u8; N];
        self.read_into(offset, &mut arr)?;
        Ok(arr)
    }

    /// Reads a fixed-size byte array `[u8; N]` at the specified `offset` without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + N <= self.length()`.
    #[inline]
    unsafe fn get_array_unchecked<const N: usize>(&self, offset: usize) -> [u8; N] {
        let mut arr = [0u8; N];
        unsafe { self.read_into_unchecked(offset, &mut arr) };
        arr
    }

    /// Copies bytes starting from `offset` into the destination slice `dest`.
    #[inline]
    fn read_into(&self, offset: usize, dest: &mut [u8]) -> BufResult<()> {
        for (i, byte) in dest.iter_mut().enumerate() {
            *byte = self.get_u8(offset + i)?;
        }
        Ok(())
    }

    /// Copies bytes starting from `offset` into the destination slice `dest` without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` and `dest.len()` that exceed the buffer is undefined behavior.
    /// The caller must ensure that `offset + dest.len() <= self.length()`.
    #[inline]
    unsafe fn read_into_unchecked(&self, offset: usize, dest: &mut [u8]) {
        for (i, byte) in dest.iter_mut().enumerate() {
            *byte = unsafe { self.get_u8_unchecked(offset + i) };
        }
    }
}

/// Mutable memory abstraction supporting random-access writes.
pub trait BufMut: Buf {
    /// Writes a single byte at the specified `offset`.
    fn set_u8(&mut self, offset: usize, val: u8) -> BufResult<()>;

    /// Writes a single byte at the specified `offset` without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset < self.length()`.
    unsafe fn set_u8_unchecked(&mut self, offset: usize, val: u8);

    /// Writes an unsigned 16-bit integer in Big Endian format.
    #[inline]
    fn set_u16_be(&mut self, offset: usize, val: u16) -> BufResult<()> {
        self.set_array(offset, &val.to_be_bytes())
    }

    /// Writes an unsigned 16-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 2 <= self.length()`.
    #[inline]
    unsafe fn set_u16_be_unchecked(&mut self, offset: usize, val: u16) {
        unsafe { self.set_array_unchecked(offset, &val.to_be_bytes()) }
    }

    /// Writes an unsigned 16-bit integer in Little Endian format.
    #[inline]
    fn set_u16_le(&mut self, offset: usize, val: u16) -> BufResult<()> {
        self.set_array(offset, &val.to_le_bytes())
    }

    /// Writes an unsigned 16-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 2 <= self.length()`.
    #[inline]
    unsafe fn set_u16_le_unchecked(&mut self, offset: usize, val: u16) {
        unsafe { self.set_array_unchecked(offset, &val.to_le_bytes()) }
    }

    /// Writes an unsigned 32-bit integer in Big Endian format.
    #[inline]
    fn set_u32_be(&mut self, offset: usize, val: u32) -> BufResult<()> {
        self.set_array(offset, &val.to_be_bytes())
    }

    /// Writes an unsigned 32-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 4 <= self.length()`.
    #[inline]
    unsafe fn set_u32_be_unchecked(&mut self, offset: usize, val: u32) {
        unsafe { self.set_array_unchecked(offset, &val.to_be_bytes()) }
    }

    /// Writes an unsigned 32-bit integer in Little Endian format.
    #[inline]
    fn set_u32_le(&mut self, offset: usize, val: u32) -> BufResult<()> {
        self.set_array(offset, &val.to_le_bytes())
    }

    /// Writes an unsigned 32-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 4 <= self.length()`.
    #[inline]
    unsafe fn set_u32_le_unchecked(&mut self, offset: usize, val: u32) {
        unsafe { self.set_array_unchecked(offset, &val.to_le_bytes()) }
    }

    /// Writes an unsigned 64-bit integer in Big Endian format.
    #[inline]
    fn set_u64_be(&mut self, offset: usize, val: u64) -> BufResult<()> {
        self.set_array(offset, &val.to_be_bytes())
    }

    /// Writes an unsigned 64-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 8 <= self.length()`.
    #[inline]
    unsafe fn set_u64_be_unchecked(&mut self, offset: usize, val: u64) {
        unsafe { self.set_array_unchecked(offset, &val.to_be_bytes()) }
    }

    /// Writes an unsigned 64-bit integer in Little Endian format.
    #[inline]
    fn set_u64_le(&mut self, offset: usize, val: u64) -> BufResult<()> {
        self.set_array(offset, &val.to_le_bytes())
    }

    /// Writes an unsigned 64-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 8 <= self.length()`.
    #[inline]
    unsafe fn set_u64_le_unchecked(&mut self, offset: usize, val: u64) {
        unsafe { self.set_array_unchecked(offset, &val.to_le_bytes()) }
    }

    /// Writes an unsigned 128-bit integer in Big Endian format.
    #[inline]
    fn set_u128_be(&mut self, offset: usize, val: u128) -> BufResult<()> {
        self.set_array(offset, &val.to_be_bytes())
    }

    /// Writes an unsigned 128-bit integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 16 <= self.length()`.
    #[inline]
    unsafe fn set_u128_be_unchecked(&mut self, offset: usize, val: u128) {
        unsafe { self.set_array_unchecked(offset, &val.to_be_bytes()) }
    }

    /// Writes an unsigned 128-bit integer in Little Endian format.
    #[inline]
    fn set_u128_le(&mut self, offset: usize, val: u128) -> BufResult<()> {
        self.set_array(offset, &val.to_le_bytes())
    }

    /// Writes an unsigned 128-bit integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + 16 <= self.length()`.
    #[inline]
    unsafe fn set_u128_le_unchecked(&mut self, offset: usize, val: u128) {
        unsafe { self.set_array_unchecked(offset, &val.to_le_bytes()) }
    }

    /// Writes an architecture-sized unsigned integer in Big Endian format.
    #[inline]
    fn set_usize_be(&mut self, offset: usize, val: usize) -> BufResult<()> {
        self.set_array(offset, &val.to_be_bytes())
    }

    /// Writes an architecture-sized unsigned integer in Big Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + core::mem::size_of::<usize>() <= self.length()`.
    #[inline]
    unsafe fn set_usize_be_unchecked(&mut self, offset: usize, val: usize) {
        unsafe { self.set_array_unchecked(offset, &val.to_be_bytes()) }
    }

    /// Writes an architecture-sized unsigned integer in Little Endian format.
    #[inline]
    fn set_usize_le(&mut self, offset: usize, val: usize) -> BufResult<()> {
        self.set_array(offset, &val.to_le_bytes())
    }

    /// Writes an architecture-sized unsigned integer in Little Endian format without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + core::mem::size_of::<usize>() <= self.length()`.
    #[inline]
    unsafe fn set_usize_le_unchecked(&mut self, offset: usize, val: usize) {
        unsafe { self.set_array_unchecked(offset, &val.to_le_bytes()) }
    }

    /// Writes a fixed-size byte array `[u8; N]` at the specified `offset`.
    #[inline]
    fn set_array<const N: usize>(&mut self, offset: usize, val: &[u8; N]) -> BufResult<()> {
        self.set_slice(offset, val)
    }

    /// Writes a fixed-size byte array `[u8; N]` at the specified `offset` without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` that is out of bounds is undefined behavior.
    /// The caller must ensure that `offset + N <= self.length()`.
    #[inline]
    unsafe fn set_array_unchecked<const N: usize>(&mut self, offset: usize, val: &[u8; N]) {
        unsafe { self.set_slice_unchecked(offset, val) }
    }

    /// Copies bytes from the source slice `src` into the buffer starting at `offset`.
    #[inline]
    fn set_slice(&mut self, offset: usize, src: &[u8]) -> BufResult<()> {
        for (i, &byte) in src.iter().enumerate() {
            self.set_u8(offset + i, byte)?;
        }
        Ok(())
    }

    /// Copies bytes from the source slice `src` into the buffer starting at `offset` without bounds checking.
    ///
    /// # Safety
    ///
    /// Calling this method with an `offset` and `src.len()` that exceed the buffer is undefined behavior.
    /// The caller must ensure that `offset + src.len() <= self.length()`.
    #[inline]
    unsafe fn set_slice_unchecked(&mut self, offset: usize, src: &[u8]) {
        for (i, &byte) in src.iter().enumerate() {
            unsafe { self.set_u8_unchecked(offset + i, byte) };
        }
    }
}

impl Buf for [u8] {
    #[inline]
    fn length(&self) -> usize {
        self.len()
    }

    #[inline]
    fn get_u8(&self, offset: usize) -> BufResult<u8> {
        self.get(offset).copied().ok_or(BufError::OutOfBounds)
    }

    #[inline]
    unsafe fn get_u8_unchecked(&self, offset: usize) -> u8 {
        unsafe { *self.get_unchecked(offset) }
    }

    #[inline]
    fn get_array<const N: usize>(&self, offset: usize) -> BufResult<[u8; N]> {
        let end = offset.checked_add(N).ok_or(BufError::OutOfBounds)?;
        let slice = self.get(offset..end).ok_or(BufError::OutOfBounds)?;
        let mut arr = [0u8; N];
        arr.copy_from_slice(slice);
        Ok(arr)
    }

    #[inline]
    unsafe fn get_array_unchecked<const N: usize>(&self, offset: usize) -> [u8; N] {
        let slice = unsafe { self.get_unchecked(offset..offset + N) };
        let mut arr = [0u8; N];
        arr.copy_from_slice(slice);
        arr
    }

    #[inline]
    fn read_into(&self, offset: usize, dest: &mut [u8]) -> BufResult<()> {
        let end = offset
            .checked_add(dest.len())
            .ok_or(BufError::OutOfBounds)?;
        let slice = self.get(offset..end).ok_or(BufError::OutOfBounds)?;
        dest.copy_from_slice(slice);
        Ok(())
    }

    #[inline]
    unsafe fn read_into_unchecked(&self, offset: usize, dest: &mut [u8]) {
        let slice = unsafe { self.get_unchecked(offset..offset + dest.len()) };
        dest.copy_from_slice(slice);
    }
}

impl BufMut for [u8] {
    #[inline]
    fn set_u8(&mut self, offset: usize, val: u8) -> BufResult<()> {
        let byte = self.get_mut(offset).ok_or(BufError::OutOfBounds)?;
        *byte = val;
        Ok(())
    }

    #[inline]
    unsafe fn set_u8_unchecked(&mut self, offset: usize, val: u8) {
        unsafe {
            *self.get_unchecked_mut(offset) = val;
        }
    }

    #[inline]
    fn set_array<const N: usize>(&mut self, offset: usize, val: &[u8; N]) -> BufResult<()> {
        self.set_slice(offset, val)
    }

    #[inline]
    unsafe fn set_array_unchecked<const N: usize>(&mut self, offset: usize, val: &[u8; N]) {
        unsafe { self.set_slice_unchecked(offset, val) }
    }

    #[inline]
    fn set_slice(&mut self, offset: usize, src: &[u8]) -> BufResult<()> {
        let end = offset.checked_add(src.len()).ok_or(BufError::OutOfBounds)?;
        let slice = self.get_mut(offset..end).ok_or(BufError::OutOfBounds)?;
        slice.copy_from_slice(src);
        Ok(())
    }

    #[inline]
    unsafe fn set_slice_unchecked(&mut self, offset: usize, src: &[u8]) {
        let slice = unsafe { self.get_unchecked_mut(offset..offset + src.len()) };
        slice.copy_from_slice(src);
    }
}

impl<const N: usize> Buf for [u8; N] {
    #[inline]
    fn length(&self) -> usize {
        self.as_slice().length()
    }

    #[inline]
    fn get_u8(&self, offset: usize) -> BufResult<u8> {
        self.as_slice().get_u8(offset)
    }

    #[inline]
    unsafe fn get_u8_unchecked(&self, offset: usize) -> u8 {
        unsafe { self.as_slice().get_u8_unchecked(offset) }
    }

    #[inline]
    fn get_array<const M: usize>(&self, offset: usize) -> BufResult<[u8; M]> {
        self.as_slice().get_array(offset)
    }

    #[inline]
    unsafe fn get_array_unchecked<const M: usize>(&self, offset: usize) -> [u8; M] {
        unsafe { self.as_slice().get_array_unchecked(offset) }
    }

    #[inline]
    fn read_into(&self, offset: usize, dest: &mut [u8]) -> BufResult<()> {
        self.as_slice().read_into(offset, dest)
    }

    #[inline]
    unsafe fn read_into_unchecked(&self, offset: usize, dest: &mut [u8]) {
        unsafe { self.as_slice().read_into_unchecked(offset, dest) }
    }
}

impl<const N: usize> BufMut for [u8; N] {
    #[inline]
    fn set_u8(&mut self, offset: usize, val: u8) -> BufResult<()> {
        self.as_mut_slice().set_u8(offset, val)
    }

    #[inline]
    unsafe fn set_u8_unchecked(&mut self, offset: usize, val: u8) {
        unsafe { self.as_mut_slice().set_u8_unchecked(offset, val) }
    }

    #[inline]
    fn set_array<const M: usize>(&mut self, offset: usize, val: &[u8; M]) -> BufResult<()> {
        self.as_mut_slice().set_array(offset, val)
    }

    #[inline]
    unsafe fn set_array_unchecked<const M: usize>(&mut self, offset: usize, val: &[u8; M]) {
        unsafe { self.as_mut_slice().set_array_unchecked(offset, val) }
    }

    #[inline]
    fn set_slice(&mut self, offset: usize, src: &[u8]) -> BufResult<()> {
        self.as_mut_slice().set_slice(offset, src)
    }

    #[inline]
    unsafe fn set_slice_unchecked(&mut self, offset: usize, src: &[u8]) {
        unsafe { self.as_mut_slice().set_slice_unchecked(offset, src) }
    }
}

impl<T: Buf + ?Sized> Buf for &T {
    #[inline]
    fn length(&self) -> usize {
        (**self).length()
    }

    #[inline]
    fn is_empty(&self) -> bool {
        (**self).is_empty()
    }

    #[inline]
    fn get_u8(&self, offset: usize) -> BufResult<u8> {
        (**self).get_u8(offset)
    }

    #[inline]
    unsafe fn get_u8_unchecked(&self, offset: usize) -> u8 {
        unsafe { (**self).get_u8_unchecked(offset) }
    }

    #[inline]
    fn get_array<const N: usize>(&self, offset: usize) -> BufResult<[u8; N]> {
        (**self).get_array(offset)
    }

    #[inline]
    unsafe fn get_array_unchecked<const N: usize>(&self, offset: usize) -> [u8; N] {
        unsafe { (**self).get_array_unchecked(offset) }
    }

    #[inline]
    fn read_into(&self, offset: usize, dest: &mut [u8]) -> BufResult<()> {
        (**self).read_into(offset, dest)
    }

    #[inline]
    unsafe fn read_into_unchecked(&self, offset: usize, dest: &mut [u8]) {
        unsafe { (**self).read_into_unchecked(offset, dest) }
    }
}

impl<T: Buf + ?Sized> Buf for &mut T {
    #[inline]
    fn length(&self) -> usize {
        (**self).length()
    }

    #[inline]
    fn is_empty(&self) -> bool {
        (**self).is_empty()
    }

    #[inline]
    fn get_u8(&self, offset: usize) -> BufResult<u8> {
        (**self).get_u8(offset)
    }

    #[inline]
    unsafe fn get_u8_unchecked(&self, offset: usize) -> u8 {
        unsafe { (**self).get_u8_unchecked(offset) }
    }

    #[inline]
    fn get_array<const N: usize>(&self, offset: usize) -> BufResult<[u8; N]> {
        (**self).get_array(offset)
    }

    #[inline]
    unsafe fn get_array_unchecked<const N: usize>(&self, offset: usize) -> [u8; N] {
        unsafe { (**self).get_array_unchecked(offset) }
    }

    #[inline]
    fn read_into(&self, offset: usize, dest: &mut [u8]) -> BufResult<()> {
        (**self).read_into(offset, dest)
    }

    #[inline]
    unsafe fn read_into_unchecked(&self, offset: usize, dest: &mut [u8]) {
        unsafe { (**self).read_into_unchecked(offset, dest) }
    }
}

impl<T: BufMut + ?Sized> BufMut for &mut T {
    #[inline]
    fn set_u8(&mut self, offset: usize, val: u8) -> BufResult<()> {
        (**self).set_u8(offset, val)
    }

    #[inline]
    unsafe fn set_u8_unchecked(&mut self, offset: usize, val: u8) {
        unsafe { (**self).set_u8_unchecked(offset, val) }
    }

    #[inline]
    fn set_array<const N: usize>(&mut self, offset: usize, val: &[u8; N]) -> BufResult<()> {
        (**self).set_array(offset, val)
    }

    #[inline]
    unsafe fn set_array_unchecked<const N: usize>(&mut self, offset: usize, val: &[u8; N]) {
        unsafe { (**self).set_array_unchecked(offset, val) }
    }

    #[inline]
    fn set_slice(&mut self, offset: usize, src: &[u8]) -> BufResult<()> {
        (**self).set_slice(offset, src)
    }

    #[inline]
    unsafe fn set_slice_unchecked(&mut self, offset: usize, src: &[u8]) {
        unsafe { (**self).set_slice_unchecked(offset, src) }
    }
}

#[cfg(feature = "alloc")]
impl Buf for Vec<u8> {
    #[inline(always)]
    fn length(&self) -> usize {
        self.as_slice().len()
    }

    fn get_u8(&self, offset: usize) -> BufResult<u8> {
        self.as_slice().get_u8(offset)
    }

    unsafe fn get_u8_unchecked(&self, offset: usize) -> u8 {
        unsafe { self.as_slice().get_u8_unchecked(offset) }
    }

    fn get_array<const N: usize>(&self, offset: usize) -> BufResult<[u8; N]> {
        self.as_slice().get_array::<N>(offset)
    }

    unsafe fn get_array_unchecked<const N: usize>(&self, offset: usize) -> [u8; N] {
        unsafe { self.as_slice().get_array_unchecked::<N>(offset) }
    }

    fn read_into(&self, offset: usize, dest: &mut [u8]) -> BufResult<()> {
        self.as_slice().read_into(offset, dest)
    }

    unsafe fn read_into_unchecked(&self, offset: usize, dest: &mut [u8]) {
        unsafe { self.as_slice().read_into_unchecked(offset, dest) }
    }
}

#[cfg(feature = "alloc")]
impl BufMut for Vec<u8> {
    fn set_u8(&mut self, offset: usize, val: u8) -> BufResult<()> {
        if offset >= self.len() {
            self.resize(offset + 1, 0);
        }
        self.as_mut_slice()[offset] = val;
        Ok(())
    }

    unsafe fn set_u8_unchecked(&mut self, offset: usize, val: u8) {
        unsafe { self.as_mut_slice().set_u8_unchecked(offset, val) }
    }

    fn set_slice(&mut self, offset: usize, src: &[u8]) -> BufResult<()> {
        let end = offset + src.len();
        if end > self.len() {
            self.resize(end, 0);
        }
        self.as_mut_slice()[offset..end].copy_from_slice(src);
        Ok(())
    }

    unsafe fn set_slice_unchecked(&mut self, offset: usize, src: &[u8]) {
        unsafe { self.as_mut_slice().set_slice_unchecked(offset, src) }
    }
}