ntex_bytes/buf/

buf_impl.rs

use std::{cmp, mem};

macro_rules! buf_get_impl {
    ($this:ident, $typ:tt::$conv:tt) => {{
        const SIZE: usize = mem::size_of::<$typ>();
        // try to convert directly from the bytes
        // this Option<ret> trick is to avoid keeping a borrow on self
        // when advance() is called (mut borrow) and to call chunk() only once
        #[allow(clippy::ptr_as_ptr)]
        let ret = $this.chunk().get(..SIZE).map(|src| {
            // SAFETY: `get(..SIZE)` yields exactly `SIZE` initialized bytes, aligned for a byte
            // array.
            unsafe { $typ::$conv(*(std::ptr::from_ref(src) as *const [_; SIZE])) }
        });

        if let Some(ret) = ret {
            // if the direct conversion was possible, advance and return
            $this.advance(SIZE);
            return ret;
        }
        // if not we copy the bytes in a temp buffer then convert
        let mut buf = [0; SIZE];
        $this.copy_to_slice(&mut buf); // (do the advance)
        return $typ::$conv(buf);
    }};
    (le => $this:ident, $typ:tt, $len_to_read:expr) => {{
        debug_assert!(mem::size_of::<$typ>() >= $len_to_read);

        // The same trick as above does not improve the best case speed.
        // It seems to be linked to the way the method is optimised by the compiler
        let mut buf = [0; (mem::size_of::<$typ>())];
        $this.copy_to_slice(&mut buf[..($len_to_read)]);
        return $typ::from_le_bytes(buf);
    }};
    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
        debug_assert!(mem::size_of::<$typ>() >= $len_to_read);

        let mut buf = [0; (mem::size_of::<$typ>())];
        $this.copy_to_slice(&mut buf[mem::size_of::<$typ>() - ($len_to_read)..]);
        return $typ::from_be_bytes(buf);
    }};
}

/// Interprets the low `nbytes` bytes of `val` as a two's complement integer.
fn sign_extend(val: u64, nbytes: usize) -> i64 {
    if nbytes == 0 {
        0
    } else {
        let shift = (8 - nbytes) * 8;
        ((val << shift).cast_signed()) >> shift
    }
}

/// Read bytes from a buffer.
///
/// A buffer stores bytes in memory such that read operations are infallible.
/// The underlying storage may or may not be in contiguous memory. A `Buf` value
/// is a cursor into the buffer. Reading from `Buf` advances the cursor
/// position. It can be thought of as an efficient `Iterator` for collections of
/// bytes.
///
/// The simplest `Buf` is a `&[u8]`.
///
/// ```
/// use ntex_bytes::Buf;
///
/// let mut buf = &b"hello world"[..];
///
/// assert_eq!(b'h', buf.get_u8());
/// assert_eq!(b'e', buf.get_u8());
/// assert_eq!(b'l', buf.get_u8());
///
/// let mut rest = [0; 8];
/// buf.copy_to_slice(&mut rest);
///
/// assert_eq!(&rest[..], &b"lo world"[..]);
/// ```
pub trait Buf {
    /// Returns the number of bytes between the current position and the end of
    /// the buffer.
    ///
    /// This value is greater than or equal to the length of the slice returned
    /// by `chunk`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"hello world"[..];
    ///
    /// assert_eq!(buf.remaining(), 11);
    ///
    /// buf.get_u8();
    ///
    /// assert_eq!(buf.remaining(), 10);
    /// ```
    ///
    /// # Implementer notes
    ///
    /// Implementations of `remaining` should ensure that the return value does
    /// not change unless a call is made to `advance` or any other function that
    /// is documented to change the `Buf`'s current position.
    fn remaining(&self) -> usize;

    /// Returns a slice starting at the current position and of length between 0
    /// and `Buf::remaining()`. Note that this *can* return shorter slice (this allows
    /// non-continuous internal representation).
    ///
    /// This is a lower level function. Most operations are done with other
    /// functions.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"hello world"[..];
    ///
    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
    ///
    /// buf.advance(6);
    ///
    /// assert_eq!(buf.chunk(), &b"world"[..]);
    /// ```
    ///
    /// # Implementer notes
    ///
    /// This function should never panic. Once the end of the buffer is reached,
    /// i.e., `Buf::remaining` returns 0, calls to `chunk` should return an
    /// empty slice.
    fn chunk(&self) -> &[u8];

    /// Advance the internal cursor of the Buf
    ///
    /// The next call to `chunk` will return a slice starting `cnt` bytes
    /// further into the underlying buffer.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"hello world"[..];
    ///
    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
    ///
    /// buf.advance(6);
    ///
    /// assert_eq!(buf.chunk(), &b"world"[..]);
    /// ```
    ///
    /// # Panics
    ///
    /// This function **may** panic if `cnt > self.remaining()`.
    ///
    /// # Implementer notes
    ///
    /// It is recommended for implementations of `advance` to panic if `cnt >
    /// self.remaining()`. If the implementation does not panic, the call must
    /// behave as if `cnt == self.remaining()`.
    ///
    /// A call with `cnt == 0` should never panic and be a no-op.
    fn advance(&mut self, cnt: usize);

    /// Returns true if there are any more bytes to consume
    ///
    /// This is equivalent to `self.remaining() != 0`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"a"[..];
    ///
    /// assert!(buf.has_remaining());
    ///
    /// buf.get_u8();
    ///
    /// assert!(!buf.has_remaining());
    /// ```
    fn has_remaining(&self) -> bool {
        self.remaining() > 0
    }

    /// Copies bytes from `self` into `dst`.
    ///
    /// The cursor is advanced by the number of bytes copied. `self` must have
    /// enough remaining bytes to fill `dst`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"hello world"[..];
    /// let mut dst = [0; 5];
    ///
    /// buf.copy_to_slice(&mut dst);
    /// assert_eq!(&b"hello"[..], &dst);
    /// assert_eq!(6, buf.remaining());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if `self.remaining() < dst.len()`
    fn copy_to_slice(&mut self, dst: &mut [u8]) {
        let mut off = 0;

        assert!(self.remaining() >= dst.len());

        while off < dst.len() {
            let src = self.chunk();
            let cnt = cmp::min(src.len(), dst.len() - off);
            dst[off..off + cnt].copy_from_slice(&src[..cnt]);
            off += cnt;

            self.advance(cnt);
        }
    }

    /// Gets an unsigned 8 bit integer from `self`.
    ///
    /// The current position is advanced by 1.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08 hello"[..];
    /// assert_eq!(8, buf.get_u8());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is no more remaining data in `self`.
    #[inline]
    fn get_u8(&mut self) -> u8 {
        assert!(self.remaining() >= 1);
        let ret = self.chunk()[0];
        self.advance(1);
        ret
    }

    /// Gets a signed 8 bit integer from `self`.
    ///
    /// The current position is advanced by 1.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08 hello"[..];
    /// assert_eq!(8, buf.get_i8());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is no more remaining data in `self`.
    #[inline]
    fn get_i8(&mut self) -> i8 {
        self.get_u8() as i8
    }

    /// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 2.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08\x09 hello"[..];
    /// assert_eq!(0x0809, buf.get_u16());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u16(&mut self) -> u16 {
        buf_get_impl!(self, u16::from_be_bytes);
    }

    /// Gets an unsigned 16 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 2.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x09\x08 hello"[..];
    /// assert_eq!(0x0809, buf.get_u16_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u16_le(&mut self) -> u16 {
        buf_get_impl!(self, u16::from_le_bytes);
    }

    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 2.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08\x09 hello"[..];
    /// assert_eq!(0x0809, buf.get_i16());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i16(&mut self) -> i16 {
        buf_get_impl!(self, i16::from_be_bytes);
    }

    /// Gets a signed 16 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 2.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x09\x08 hello"[..];
    /// assert_eq!(0x0809, buf.get_i16_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i16_le(&mut self) -> i16 {
        buf_get_impl!(self, i16::from_le_bytes);
    }

    /// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
    ///
    /// The current position is advanced by 4.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
    /// assert_eq!(0x0809A0A1, buf.get_u32());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u32(&mut self) -> u32 {
        buf_get_impl!(self, u32::from_be_bytes);
    }

    /// Gets an unsigned 32 bit integer from `self` in the little-endian byte order.
    ///
    /// The current position is advanced by 4.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
    /// assert_eq!(0x0809A0A1, buf.get_u32_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u32_le(&mut self) -> u32 {
        buf_get_impl!(self, u32::from_le_bytes);
    }

    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 4.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
    /// assert_eq!(0x0809A0A1, buf.get_i32());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i32(&mut self) -> i32 {
        buf_get_impl!(self, i32::from_be_bytes);
    }

    /// Gets a signed 32 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 4.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
    /// assert_eq!(0x0809A0A1, buf.get_i32_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i32_le(&mut self) -> i32 {
        buf_get_impl!(self, i32::from_le_bytes);
    }

    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
    /// assert_eq!(0x0102030405060708, buf.get_u64());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u64(&mut self) -> u64 {
        buf_get_impl!(self, u64::from_be_bytes);
    }

    /// Gets an unsigned 64 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
    /// assert_eq!(0x0102030405060708, buf.get_u64_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u64_le(&mut self) -> u64 {
        buf_get_impl!(self, u64::from_le_bytes);
    }

    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
    /// assert_eq!(0x0102030405060708, buf.get_i64());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i64(&mut self) -> i64 {
        buf_get_impl!(self, i64::from_be_bytes);
    }

    /// Gets a signed 64 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
    /// assert_eq!(0x0102030405060708, buf.get_i64_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i64_le(&mut self) -> i64 {
        buf_get_impl!(self, i64::from_le_bytes);
    }

    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 16.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u128(&mut self) -> u128 {
        buf_get_impl!(self, u128::from_be_bytes);
    }

    /// Gets an unsigned 128 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 16.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_u128_le(&mut self) -> u128 {
        buf_get_impl!(self, u128::from_le_bytes);
    }

    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by 16.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i128(&mut self) -> i128 {
        buf_get_impl!(self, i128::from_be_bytes);
    }

    /// Gets a signed 128 bit integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by 16.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_i128_le(&mut self) -> i128 {
        buf_get_impl!(self, i128::from_le_bytes);
    }

    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by `nbytes`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x01\x02\x03 hello"[..];
    /// assert_eq!(0x010203, buf.get_uint(3));
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`,
    /// or if `nbytes > 8`.
    #[inline]
    fn get_uint(&mut self, nbytes: usize) -> u64 {
        buf_get_impl!(be => self, u64, nbytes);
    }

    /// Gets an unsigned n-byte integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by `nbytes`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x03\x02\x01 hello"[..];
    /// assert_eq!(0x010203, buf.get_uint_le(3));
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`,
    /// or if `nbytes > 8`.
    #[inline]
    fn get_uint_le(&mut self, nbytes: usize) -> u64 {
        buf_get_impl!(le => self, u64, nbytes);
    }

    /// Gets a signed n-byte integer from `self` in big-endian byte order.
    ///
    /// The current position is advanced by `nbytes`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x01\x02\x03\xff\xfe"[..];
    /// assert_eq!(0x010203, buf.get_int(3));
    /// assert_eq!(-2, buf.get_int(2));
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`,
    /// or if `nbytes > 8`.
    #[inline]
    fn get_int(&mut self, nbytes: usize) -> i64 {
        sign_extend(self.get_uint(nbytes), nbytes)
    }

    /// Gets a signed n-byte integer from `self` in little-endian byte order.
    ///
    /// The current position is advanced by `nbytes`.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x03\x02\x01\xfe\xff"[..];
    /// assert_eq!(0x010203, buf.get_int_le(3));
    /// assert_eq!(-2, buf.get_int_le(2));
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`,
    /// or if `nbytes > 8`.
    #[inline]
    fn get_int_le(&mut self, nbytes: usize) -> i64 {
        sign_extend(self.get_uint_le(nbytes), nbytes)
    }

    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
    /// `self` in big-endian byte order.
    ///
    /// The current position is advanced by 4.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
    /// assert_eq!(1.2f32, buf.get_f32());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_f32(&mut self) -> f32 {
        f32::from_bits(Self::get_u32(self))
    }

    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
    /// `self` in little-endian byte order.
    ///
    /// The current position is advanced by 4.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
    /// assert_eq!(1.2f32, buf.get_f32_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_f32_le(&mut self) -> f32 {
        f32::from_bits(Self::get_u32_le(self))
    }

    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
    /// `self` in big-endian byte order.
    ///
    /// The current position is advanced by 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
    /// assert_eq!(1.2f64, buf.get_f64());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_f64(&mut self) -> f64 {
        f64::from_bits(Self::get_u64(self))
    }

    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
    /// `self` in little-endian byte order.
    ///
    /// The current position is advanced by 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::Buf;
    ///
    /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
    /// assert_eq!(1.2f64, buf.get_f64_le());
    /// ```
    ///
    /// # Panics
    ///
    /// This function panics if there is not enough remaining data in `self`.
    #[inline]
    fn get_f64_le(&mut self) -> f64 {
        f64::from_bits(Self::get_u64_le(self))
    }

    /// Consumes remaining bytes inside self and returns new instance of `Bytes`
    ///
    /// # Examples
    ///
    /// ```
    /// use ntex_bytes::{Buf};
    ///
    /// let bytes = (&b"hello world"[..]).to_bytes();
    /// assert_eq!(&bytes[..], &b"hello world"[..]);
    /// ```
    #[inline]
    #[allow(clippy::wrong_self_convention)]
    fn to_bytes(&mut self) -> crate::Bytes {
        use super::BufMut;
        let mut ret = crate::BytesMut::with_capacity(self.remaining());
        ret.put(self);
        ret.freeze()
    }
}

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

    #[inline]
    fn chunk(&self) -> &[u8] {
        (**self).chunk()
    }

    #[inline]
    fn advance(&mut self, cnt: usize) {
        (**self).advance(cnt);
    }
}

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

    #[inline]
    fn chunk(&self) -> &[u8] {
        (**self).chunk()
    }

    fn advance(&mut self, cnt: usize) {
        (**self).advance(cnt);
    }
}

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

    #[inline]
    fn chunk(&self) -> &[u8] {
        self
    }

    #[inline]
    fn advance(&mut self, cnt: usize) {
        *self = &self[cnt..];
    }

    #[inline]
    fn get_u8(&mut self) -> u8 {
        let ret = self[0];
        self.advance(1);
        ret
    }
}

impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
    fn remaining(&self) -> usize {
        let len = self.get_ref().as_ref().len();
        let pos = self.position();

        if pos >= len as u64 {
            return 0;
        }

        len - pos as usize
    }

    fn chunk(&self) -> &[u8] {
        let len = self.get_ref().as_ref().len();
        let pos = self.position();

        if pos >= len as u64 {
            return &[];
        }

        &self.get_ref().as_ref()[pos as usize..]
    }

    fn advance(&mut self, cnt: usize) {
        if cnt == 0 {
            return;
        }
        let pos = self.position().checked_add(cnt as u64).expect("overflow");

        assert!(pos <= self.get_ref().as_ref().len() as u64);
        self.set_position(pos);
    }
}

// The existence of this function makes the compiler catch if the Buf
// trait is "object-safe" or not.
fn _assert_trait_object(_b: &dyn Buf) {}

#[cfg(test)]
#[allow(clippy::float_cmp)]
mod tests {
    use super::*;

    /// STATEMENT: `Buf` reads consume the expected bytes and decode numeric values in the requested byte order.
    ///
    /// HOW:
    /// - Copy and advance slices, boxed slices, and cursors, checking remaining chunks and exhausted states.
    /// - Decode signed and unsigned integers, variable-width integers, and floats in both byte orders and convert a slice to `Bytes`.
    #[test]
    fn buf_tests() {
        let mut buf = &b"a"[..];
        assert!(buf.has_remaining());
        buf.get_u8();
        assert!(!buf.has_remaining());

        let mut buf = &b"hello world"[..];
        let mut dst = [0; 5];
        buf.copy_to_slice(&mut dst);
        assert_eq!(&b"hello"[..], &dst);
        assert_eq!(6, buf.remaining());
        buf.advance(1);
        assert_eq!(Buf::chunk(&buf), &b"world"[..]);
        assert_eq!(buf.get_u8(), b'w');
        assert_eq!(Buf::chunk(&buf), &b"orld"[..]);

        let mut buf = &b"hello world"[..];
        buf.advance(5);
        let mut buf = Box::new(buf);
        assert_eq!(buf.remaining(), 6);
        assert_eq!(buf.chunk(), b" world");
        buf.advance(1);
        assert_eq!(buf.chunk(), b"world");

        let mut buf = std::io::Cursor::new(b" world");
        assert_eq!(buf.remaining(), 6);
        assert_eq!(buf.chunk(), b" world");
        buf.advance(1);
        assert_eq!(buf.chunk(), b"world");
        buf.advance(5);
        assert_eq!(buf.remaining(), 0);
        assert_eq!(buf.chunk(), b"");

        let mut buf = &b"\x08 hello"[..];
        assert_eq!(8, buf.get_u8());

        let mut buf = &b"\x08 hello"[..];
        assert_eq!(8, buf.get_i8());

        let mut buf = &b"\x08\x09 hello"[..];
        assert_eq!(0x0809, buf.get_u16());

        let mut buf = &b"\x09\x08 hello"[..];
        assert_eq!(0x0809, buf.get_u16_le());

        let mut buf = &b"\x08\x09 hello"[..];
        assert_eq!(0x0809, buf.get_i16());

        let mut buf = &b"\x09\x08 hello"[..];
        assert_eq!(0x0809, buf.get_i16_le());

        let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
        assert_eq!(0x0809_A0A1, buf.get_u32());

        let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
        assert_eq!(0x0809_A0A1, buf.get_u32_le());

        let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
        assert_eq!(0x0809_A0A1, buf.get_i32());

        let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
        assert_eq!(0x0809_A0A1, buf.get_i32_le());

        let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
        assert_eq!(0x0102_0304_0506_0708, buf.get_u64());

        let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
        assert_eq!(0x0102_0304_0506_0708, buf.get_u64_le());

        let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
        assert_eq!(0x0102_0304_0506_0708, buf.get_i64());

        let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
        assert_eq!(0x0102_0304_0506_0708, buf.get_i64_le());

        let mut buf =
            &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
        assert_eq!(0x0102_0304_0506_0708_0910_1112_1314_1516, buf.get_u128());

        let mut buf =
            &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
        assert_eq!(0x0102_0304_0506_0708_0910_1112_1314_1516, buf.get_u128_le());

        let mut buf =
            &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello"[..];
        assert_eq!(0x0102_0304_0506_0708_0910_1112_1314_1516, buf.get_i128());

        let mut buf =
            &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
        assert_eq!(0x0102_0304_0506_0708_0910_1112_1314_1516, buf.get_i128_le());

        let mut buf = &b"\x01\x02\x03 hello"[..];
        assert_eq!(0x01_0203, buf.get_uint(3));

        let mut buf = &b"\x03\x02\x01 hello"[..];
        assert_eq!(0x01_0203, buf.get_uint_le(3));

        let mut buf = &b"\x01\x02\x03 hello"[..];
        assert_eq!(0x01_0203, buf.get_int(3));

        let mut buf = &b"\x03\x02\x01 hello"[..];
        assert_eq!(0x01_0203, buf.get_int_le(3));

        let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
        assert_eq!(1.2f32, buf.get_f32());

        let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
        assert_eq!(1.2f32, buf.get_f32_le());

        let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
        assert_eq!(1.2f64, buf.get_f64());

        let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
        assert_eq!(1.2f64, buf.get_f64_le());

        let bytes = (&b"hello world"[..]).to_bytes();
        assert_eq!(&bytes[..], &b"hello world"[..]);
    }

    /// STATEMENT: A cursor positioned beyond its input is empty and permits zero advancement without moving.
    ///
    /// HOW:
    /// - Set a cursor over `abc` to position ten, check empty remaining data, advance zero, and verify position ten remains.
    #[test]
    fn cursor_advance_past_end() {
        let mut buf = std::io::Cursor::new(b"abc");
        buf.set_position(10);
        assert_eq!(buf.remaining(), 0);
        assert_eq!(buf.chunk(), b"");
        buf.advance(0);
        assert_eq!(buf.position(), 10);
    }

    /// STATEMENT: Advancing an out-of-range high cursor position panics instead of wrapping to a valid offset.
    ///
    /// HOW:
    /// - Position a cursor over `abc` at `(1u64 << 32) + 1`, advance one, and expect an assertion failure.
    #[test]
    #[should_panic(expected = "assertion failed")]
    fn cursor_advance_high_position() {
        // must not wrap to a valid offset on 32-bit targets
        let mut buf = std::io::Cursor::new(b"abc");
        buf.set_position((1u64 << 32) + 1);
        buf.advance(1);
    }

    struct Chunks(Vec<&'static [u8]>);

    impl Buf for Chunks {
        fn remaining(&self) -> usize {
            self.0.iter().map(|c| c.len()).sum()
        }

        fn chunk(&self) -> &[u8] {
            self.0.first().copied().unwrap_or_default()
        }

        fn advance(&mut self, mut cnt: usize) {
            while cnt > 0 {
                let n = cnt.min(self.0[0].len());
                self.0[0] = &self.0[0][n..];
                if self.0[0].is_empty() {
                    self.0.remove(0);
                }
                cnt -= n;
            }
        }
    }

    /// STATEMENT: Default `Buf` byte reads work across separate chunks and report exhaustion.
    ///
    /// HOW:
    /// - Read `a`, `b`, and `c` from `Chunks` containing `a` and `bc`, then verify `has_remaining` is false.
    #[test]
    fn default_methods() {
        let mut buf = Chunks(vec![b"a", b"bc"]);
        assert_eq!(buf.get_u8(), b'a');
        assert_eq!(buf.get_u8(), b'b');
        assert_eq!(buf.get_u8(), b'c');
        assert!(!buf.has_remaining());
    }
}