feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

11 files changed, 0 insertions, 5784 deletions

diff --git a/vendor/bytes/src/buf/buf_impl.rs b/vendor/bytes/src/buf/buf_impl.rs
deleted file mode 100644
index 192034fb..00000000
--- a/vendor/bytes/src/buf/buf_impl.rs
+++ /dev/null
@@ -1,2962 +0,0 @@
-#[cfg(feature = "std")]
-use crate::buf::{reader, Reader};
-use crate::buf::{take, Chain, Take};
-#[cfg(feature = "std")]
-use crate::{min_u64_usize, saturating_sub_usize_u64};
-use crate::{panic_advance, panic_does_not_fit, TryGetError};
-
-#[cfg(feature = "std")]
-use std::io::IoSlice;
-
-use alloc::boxed::Box;
-
-macro_rules! buf_try_get_impl {
-    ($this:ident, $typ:tt::$conv:tt) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        if $this.remaining() < SIZE {
-            return Err(TryGetError {
-                requested: SIZE,
-                available: $this.remaining(),
-            });
-        }
-
-        // 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 bytes() only once
-        let ret = $this
-            .chunk()
-            .get(..SIZE)
-            .map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) });
-
-        if let Some(ret) = ret {
-            // if the direct conversion was possible, advance and return
-            $this.advance(SIZE);
-            return Ok(ret);
-        } else {
-            // 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 Ok($typ::$conv(buf));
-        }
-    }};
-    (le => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        // 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; SIZE];
-
-        let subslice = match buf.get_mut(..$len_to_read) {
-            Some(subslice) => subslice,
-            None => panic_does_not_fit(SIZE, $len_to_read),
-        };
-
-        $this.try_copy_to_slice(subslice)?;
-        return Ok($typ::from_le_bytes(buf));
-    }};
-    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        const SIZE: usize = core::mem::size_of::<$typ>();
-
-        let slice_at = match SIZE.checked_sub($len_to_read) {
-            Some(slice_at) => slice_at,
-            None => panic_does_not_fit(SIZE, $len_to_read),
-        };
-
-        let mut buf = [0; SIZE];
-        $this.try_copy_to_slice(&mut buf[slice_at..])?;
-        return Ok($typ::from_be_bytes(buf));
-    }};
-}
-
-macro_rules! buf_get_impl {
-    ($this:ident, $typ:tt::$conv:tt) => {{
-        return (|| buf_try_get_impl!($this, $typ::$conv))()
-            .unwrap_or_else(|error| panic_advance(&error));
-    }};
-    (le => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        return (|| buf_try_get_impl!(le => $this, $typ, $len_to_read))()
-            .unwrap_or_else(|error| panic_advance(&error));
-    }};
-    (be => $this:ident, $typ:tt, $len_to_read:expr) => {{
-        return (|| buf_try_get_impl!(be => $this, $typ, $len_to_read))()
-            .unwrap_or_else(|error| panic_advance(&error));
-    }};
-}
-
-// https://en.wikipedia.org/wiki/Sign_extension
-fn sign_extend(val: u64, nbytes: usize) -> i64 {
-    let shift = (8 - nbytes) * 8;
-    (val << shift) as i64 >> 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 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 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 a shorter slice (this
-    /// allows non-continuous internal representation).
-    ///
-    /// This is a lower level function. Most operations are done with other
-    /// functions.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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. `chunk()` should return an empty
-    /// slice **if and only if** `remaining()` returns 0. In other words,
-    /// `chunk()` returning an empty slice implies that `remaining()` will
-    /// return 0 and `remaining()` returning 0 implies that `chunk()` will
-    /// return an empty slice.
-    // The `chunk` method was previously called `bytes`. This alias makes the rename
-    // more easily discoverable.
-    #[cfg_attr(docsrs, doc(alias = "bytes"))]
-    fn chunk(&self) -> &[u8];
-
-    /// Fills `dst` with potentially multiple slices starting at `self`'s
-    /// current position.
-    ///
-    /// If the `Buf` is backed by disjoint slices of bytes, `chunk_vectored` enables
-    /// fetching more than one slice at once. `dst` is a slice of `IoSlice`
-    /// references, enabling the slice to be directly used with [`writev`]
-    /// without any further conversion. The sum of the lengths of all the
-    /// buffers written to `dst` will be less than or equal to `Buf::remaining()`.
-    ///
-    /// The entries in `dst` will be overwritten, but the data **contained** by
-    /// the slices **will not** be modified. The return value is the number of
-    /// slices written to `dst`. If `Buf::remaining()` is non-zero, then this
-    /// writes at least one non-empty slice to `dst`.
-    ///
-    /// This is a lower level function. Most operations are done with other
-    /// functions.
-    ///
-    /// # Implementer notes
-    ///
-    /// This function should never panic. Once the end of the buffer is reached,
-    /// i.e., `Buf::remaining` returns 0, calls to `chunk_vectored` must return 0
-    /// without mutating `dst`.
-    ///
-    /// Implementations should also take care to properly handle being called
-    /// with `dst` being a zero length slice.
-    ///
-    /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        if dst.is_empty() {
-            return 0;
-        }
-
-        if self.has_remaining() {
-            dst[0] = IoSlice::new(self.chunk());
-            1
-        } else {
-            0
-        }
-    }
-
-    /// 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 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 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 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]) {
-        self.try_copy_to_slice(dst)
-            .unwrap_or_else(|error| panic_advance(&error));
-    }
-
-    /// Gets an unsigned 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    fn get_u8(&mut self) -> u8 {
-        if self.remaining() < 1 {
-            panic_advance(&TryGetError {
-                requested: 1,
-                available: 0,
-            })
-        }
-        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 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`.
-    fn get_i8(&mut self) -> i8 {
-        if self.remaining() < 1 {
-            panic_advance(&TryGetError {
-                requested: 1,
-                available: 0,
-            });
-        }
-        let ret = self.chunk()[0] as i8;
-        self.advance(1);
-        ret
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_u16_le(&mut self) -> u16 {
-        buf_get_impl!(self, u16::from_le_bytes);
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809, buf.get_u16_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u16_ne(&mut self) -> u16 {
-        buf_get_impl!(self, u16::from_ne_bytes);
-    }
-
-    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_i16_le(&mut self) -> i16 {
-        buf_get_impl!(self, i16::from_le_bytes);
-    }
-
-    /// Gets a signed 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809, buf.get_i16_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i16_ne(&mut self) -> i16 {
-        buf_get_impl!(self, i16::from_ne_bytes);
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_u32_le(&mut self) -> u32 {
-        buf_get_impl!(self, u32::from_le_bytes);
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809A0A1, buf.get_u32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u32_ne(&mut self) -> u32 {
-        buf_get_impl!(self, u32::from_ne_bytes);
-    }
-
-    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_i32_le(&mut self) -> i32 {
-        buf_get_impl!(self, i32::from_le_bytes);
-    }
-
-    /// Gets a signed 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(0x0809A0A1, buf.get_i32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i32_ne(&mut self) -> i32 {
-        buf_get_impl!(self, i32::from_ne_bytes);
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_u64_le(&mut self) -> u64 {
-        buf_get_impl!(self, u64::from_le_bytes);
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x0102030405060708, buf.get_u64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u64_ne(&mut self) -> u64 {
-        buf_get_impl!(self, u64::from_ne_bytes);
-    }
-
-    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_i64_le(&mut self) -> i64 {
-        buf_get_impl!(self, i64::from_le_bytes);
-    }
-
-    /// Gets a signed 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x0102030405060708, buf.get_i64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i64_ne(&mut self) -> i64 {
-        buf_get_impl!(self, i64::from_ne_bytes);
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_u128_le(&mut self) -> u128 {
-        buf_get_impl!(self, u128::from_le_bytes);
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_u128_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_u128_ne(&mut self) -> u128 {
-        buf_get_impl!(self, u128::from_ne_bytes);
-    }
-
-    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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`.
-    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 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`.
-    fn get_i128_le(&mut self) -> i128 {
-        buf_get_impl!(self, i128::from_le_bytes);
-    }
-
-    /// Gets a signed 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x01020304050607080910111213141516, buf.get_i128_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_i128_ne(&mut self) -> i128 {
-        buf_get_impl!(self, i128::from_ne_bytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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` is greater than 8.
-    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 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` is greater than 8.
-    fn get_uint_le(&mut self, nbytes: usize) -> u64 {
-        buf_get_impl!(le => self, u64, nbytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x010203, buf.get_uint_ne(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
-        if cfg!(target_endian = "big") {
-            self.get_uint(nbytes)
-        } else {
-            self.get_uint_le(nbytes)
-        }
-    }
-
-    /// Gets a signed n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(0x010203, buf.get_int(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    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 bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(0x010203, buf.get_int_le(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_int_le(&mut self, nbytes: usize) -> i64 {
-        sign_extend(self.get_uint_le(nbytes), nbytes)
-    }
-
-    /// Gets a signed n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(0x010203, buf.get_int_ne(3));
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`, or
-    /// if `nbytes` is greater than 8.
-    fn get_int_ne(&mut self, nbytes: usize) -> i64 {
-        if cfg!(target_endian = "big") {
-            self.get_int(nbytes)
-        } else {
-            self.get_int_le(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 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`.
-    fn get_f32(&mut self) -> f32 {
-        f32::from_bits(self.get_u32())
-    }
-
-    /// 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 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`.
-    fn get_f32_le(&mut self) -> f32 {
-        f32::from_bits(self.get_u32_le())
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\x99\x99\x9A hello",
-    ///     false => b"\x9A\x99\x99\x3F hello",
-    /// };
-    /// assert_eq!(1.2f32, buf.get_f32_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f32_ne(&mut self) -> f32 {
-        f32::from_bits(self.get_u32_ne())
-    }
-
-    /// 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 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`.
-    fn get_f64(&mut self) -> f64 {
-        f64::from_bits(self.get_u64())
-    }
-
-    /// 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 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`.
-    fn get_f64_le(&mut self) -> f64 {
-        f64::from_bits(self.get_u64_le())
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
-    ///     false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
-    /// };
-    /// assert_eq!(1.2f64, buf.get_f64_ne());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining data in `self`.
-    fn get_f64_ne(&mut self) -> f64 {
-        f64::from_bits(self.get_u64_ne())
-    }
-
-    /// 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`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"hello world"[..];
-    /// let mut dst = [0; 5];
-    ///
-    /// assert_eq!(Ok(()), buf.try_copy_to_slice(&mut dst));
-    /// assert_eq!(&b"hello"[..], &dst);
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"hello world"[..];
-    /// let mut dst = [0; 12];
-    ///
-    /// assert_eq!(Err(TryGetError{requested: 12, available: 11}), buf.try_copy_to_slice(&mut dst));
-    /// assert_eq!(11, buf.remaining());
-    /// ```
-    fn try_copy_to_slice(&mut self, mut dst: &mut [u8]) -> Result<(), TryGetError> {
-        if self.remaining() < dst.len() {
-            return Err(TryGetError {
-                requested: dst.len(),
-                available: self.remaining(),
-            });
-        }
-
-        while !dst.is_empty() {
-            let src = self.chunk();
-            let cnt = usize::min(src.len(), dst.len());
-
-            dst[..cnt].copy_from_slice(&src[..cnt]);
-            dst = &mut dst[cnt..];
-
-            self.advance(cnt);
-        }
-        Ok(())
-    }
-
-    /// Gets an unsigned 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08 hello"[..];
-    /// assert_eq!(Ok(0x08_u8), buf.try_get_u8());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b""[..];
-    /// assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8());
-    /// ```
-    fn try_get_u8(&mut self) -> Result<u8, TryGetError> {
-        if self.remaining() < 1 {
-            return Err(TryGetError {
-                requested: 1,
-                available: self.remaining(),
-            });
-        }
-        let ret = self.chunk()[0];
-        self.advance(1);
-        Ok(ret)
-    }
-
-    /// Gets a signed 8 bit integer from `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08 hello"[..];
-    /// assert_eq!(Ok(0x08_i8), buf.try_get_i8());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b""[..];
-    /// assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_i8());
-    /// ```
-    fn try_get_i8(&mut self) -> Result<i8, TryGetError> {
-        if self.remaining() < 1 {
-            return Err(TryGetError {
-                requested: 1,
-                available: self.remaining(),
-            });
-        }
-        let ret = self.chunk()[0] as i8;
-        self.advance(1);
-        Ok(ret)
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09 hello"[..];
-    /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_u16(&mut self) -> Result<u16, TryGetError> {
-        buf_try_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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_le());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> {
-        buf_try_get_impl!(self, u16::from_le_bytes)
-    }
-
-    /// Gets an unsigned 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809_u16), buf.try_get_u16_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_u16_ne());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> {
-        buf_try_get_impl!(self, u16::from_ne_bytes)
-    }
-
-    /// Gets a signed 16 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09 hello"[..];
-    /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_i16(&mut self) -> Result<i16, TryGetError> {
-        buf_try_get_impl!(self, i16::from_be_bytes)
-    }
-
-    /// Gets an signed 16 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_le());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> {
-        buf_try_get_impl!(self, i16::from_le_bytes)
-    }
-
-    /// Gets a signed 16 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09 hello",
-    ///     false => b"\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809_i16), buf.try_get_i16_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08"[..];
-    /// assert_eq!(Err(TryGetError{requested: 2, available: 1}), buf.try_get_i16_ne());
-    /// assert_eq!(1, buf.remaining());
-    /// ```
-    fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> {
-        buf_try_get_impl!(self, i16::from_ne_bytes)
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1), buf.try_get_u32());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_u32(&mut self) -> Result<u32, TryGetError> {
-        buf_try_get_impl!(self, u32::from_be_bytes)
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_le());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> {
-        buf_try_get_impl!(self, u32::from_le_bytes)
-    }
-
-    /// Gets an unsigned 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809A0A1_u32), buf.try_get_u32_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_u32_ne());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> {
-        buf_try_get_impl!(self, u32::from_ne_bytes)
-    }
-
-    /// Gets a signed 32 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x09\xA0\xA1 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_i32(&mut self) -> Result<i32, TryGetError> {
-        buf_try_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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\xA1\xA0\x09\x08 hello"[..];
-    /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_le());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> {
-        buf_try_get_impl!(self, i32::from_le_bytes)
-    }
-
-    /// Gets a signed 32 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x08\x09\xA0\xA1 hello",
-    ///     false => b"\xA1\xA0\x09\x08 hello",
-    /// };
-    /// assert_eq!(Ok(0x0809A0A1_i32), buf.try_get_i32_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x09\xA0"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_i32_ne());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> {
-        buf_try_get_impl!(self, i32::from_ne_bytes)
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_u64(&mut self) -> Result<u64, TryGetError> {
-        buf_try_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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_le());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(self, u64::from_le_bytes)
-    }
-
-    /// Gets an unsigned 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x0102030405060708_u64), buf.try_get_u64_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_u64_ne());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(self, u64::from_ne_bytes)
-    }
-
-    /// Gets a signed 64 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_i64(&mut self) -> Result<i64, TryGetError> {
-        buf_try_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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_le());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(self, i64::from_le_bytes)
-    }
-
-    /// Gets a signed 64 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08 hello",
-    ///     false => b"\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x0102030405060708_i64), buf.try_get_i64_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_i64_ne());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(self, i64::from_ne_bytes)
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_u128(&mut self) -> Result<u128, TryGetError> {
-        buf_try_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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_le());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> {
-        buf_try_get_impl!(self, u128::from_le_bytes)
-    }
-
-    /// Gets an unsigned 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_u128), buf.try_get_u128_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_u128_ne());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> {
-        buf_try_get_impl!(self, u128::from_ne_bytes)
-    }
-
-    /// Gets a signed 128 bit integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_i128(&mut self) -> Result<i128, TryGetError> {
-        buf_try_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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use 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!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_le());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> {
-        buf_try_get_impl!(self, i128::from_le_bytes)
-    }
-
-    /// Gets a signed 128 bit integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16 hello",
-    ///     false => b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x01020304050607080910111213141516_i128), buf.try_get_i128_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15"[..];
-    /// assert_eq!(Err(TryGetError{requested: 16, available: 15}), buf.try_get_i128_ne());
-    /// assert_eq!(15, buf.remaining());
-    /// ```
-    fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> {
-        buf_try_get_impl!(self, i128::from_ne_bytes)
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` > 8.
-    fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-        buf_try_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`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint_le(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_le(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` > 8.
-    fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-        buf_try_get_impl!(le => self, u64, nbytes);
-    }
-
-    /// Gets an unsigned n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x010203_u64), buf.try_get_uint_ne(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03",
-    ///     false => b"\x03\x02\x01",
-    /// };
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_uint_ne(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-        if cfg!(target_endian = "big") {
-            self.try_get_uint(nbytes)
-        } else {
-            self.try_get_uint_le(nbytes)
-        }
-    }
-
-    /// Gets a signed n-byte integer from `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x01\x02\x03 hello"[..];
-    /// assert_eq!(Ok(0x010203_i64), buf.try_get_int(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(be => self, i64, nbytes);
-    }
-
-    /// Gets a signed n-byte integer from `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x03\x02\x01 hello"[..];
-    /// assert_eq!(Ok(0x010203_i64), buf.try_get_int_le(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x01\x02\x03"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_le(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-        buf_try_get_impl!(le => self, i64, nbytes);
-    }
-
-    /// Gets a signed n-byte integer from `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03 hello",
-    ///     false => b"\x03\x02\x01 hello",
-    /// };
-    /// assert_eq!(Ok(0x010203_i64), buf.try_get_int_ne(3));
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x01\x02\x03",
-    ///     false => b"\x03\x02\x01",
-    /// };
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_int_ne(4));
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `nbytes` is greater than 8.
-    fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-        if cfg!(target_endian = "big") {
-            self.try_get_int(nbytes)
-        } else {
-            self.try_get_int_le(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.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x3F\x99\x99\x9A hello"[..];
-    /// assert_eq!(1.2f32, buf.get_f32());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\x99\x99"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_f32(&mut self) -> Result<f32, TryGetError> {
-        Ok(f32::from_bits(self.try_get_u32()?))
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x9A\x99\x99\x3F hello"[..];
-    /// assert_eq!(1.2f32, buf.get_f32_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\x99\x99"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_le());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> {
-        Ok(f32::from_bits(self.try_get_u32_le()?))
-    }
-
-    /// Gets an IEEE754 single-precision (4 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\x99\x99\x9A hello",
-    ///     false => b"\x9A\x99\x99\x3F hello",
-    /// };
-    /// assert_eq!(1.2f32, buf.get_f32_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\x99\x99"[..];
-    /// assert_eq!(Err(TryGetError{requested: 4, available: 3}), buf.try_get_f32_ne());
-    /// assert_eq!(3, buf.remaining());
-    /// ```
-    fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> {
-        Ok(f32::from_bits(self.try_get_u32_ne()?))
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello"[..];
-    /// assert_eq!(1.2f64, buf.get_f64());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_f64(&mut self) -> Result<f64, TryGetError> {
-        Ok(f64::from_bits(self.try_get_u64()?))
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = &b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello"[..];
-    /// assert_eq!(1.2f64, buf.get_f64_le());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_le());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> {
-        Ok(f64::from_bits(self.try_get_u64_le()?))
-    }
-
-    /// Gets an IEEE754 double-precision (8 bytes) floating point number from
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// Returns `Err(TryGetError)` when there are not enough
-    /// remaining bytes to read the value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf: &[u8] = match cfg!(target_endian = "big") {
-    ///     true => b"\x3F\xF3\x33\x33\x33\x33\x33\x33 hello",
-    ///     false => b"\x33\x33\x33\x33\x33\x33\xF3\x3F hello",
-    /// };
-    /// assert_eq!(1.2f64, buf.get_f64_ne());
-    /// assert_eq!(6, buf.remaining());
-    /// ```
-    ///
-    /// ```
-    /// use bytes::{Buf, TryGetError};
-    ///
-    /// let mut buf = &b"\x3F\xF3\x33\x33\x33\x33\x33"[..];
-    /// assert_eq!(Err(TryGetError{requested: 8, available: 7}), buf.try_get_f64_ne());
-    /// assert_eq!(7, buf.remaining());
-    /// ```
-    fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> {
-        Ok(f64::from_bits(self.try_get_u64_ne()?))
-    }
-
-    /// Consumes `len` bytes inside self and returns new instance of `Bytes`
-    /// with this data.
-    ///
-    /// This function may be optimized by the underlying type to avoid actual
-    /// copies. For example, `Bytes` implementation will do a shallow copy
-    /// (ref-count increment).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let bytes = (&b"hello world"[..]).copy_to_bytes(5);
-    /// assert_eq!(&bytes[..], &b"hello"[..]);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if `len > self.remaining()`.
-    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-        use super::BufMut;
-
-        if self.remaining() < len {
-            panic_advance(&TryGetError {
-                requested: len,
-                available: self.remaining(),
-            });
-        }
-
-        let mut ret = crate::BytesMut::with_capacity(len);
-        ret.put(self.take(len));
-        ret.freeze()
-    }
-
-    /// Creates an adaptor which will read at most `limit` bytes from `self`.
-    ///
-    /// This function returns a new instance of `Buf` which will read at most
-    /// `limit` bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world"[..].take(5);
-    /// let mut dst = vec![];
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(dst, b"hello");
-    ///
-    /// let mut buf = buf.into_inner();
-    /// dst.clear();
-    /// dst.put(&mut buf);
-    /// assert_eq!(dst, b" world");
-    /// ```
-    fn take(self, limit: usize) -> Take<Self>
-    where
-        Self: Sized,
-    {
-        take::new(self, limit)
-    }
-
-    /// Creates an adaptor which will chain this buffer with another.
-    ///
-    /// The returned `Buf` instance will first consume all bytes from `self`.
-    /// Afterwards the output is equivalent to the output of next.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut chain = b"hello "[..].chain(&b"world"[..]);
-    ///
-    /// let full = chain.copy_to_bytes(11);
-    /// assert_eq!(full.chunk(), b"hello world");
-    /// ```
-    fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
-    where
-        Self: Sized,
-    {
-        Chain::new(self, next)
-    }
-
-    /// Creates an adaptor which implements the `Read` trait for `self`.
-    ///
-    /// This function returns a new value which implements `Read` by adapting
-    /// the `Read` trait functions to the `Buf` trait functions. Given that
-    /// `Buf` operations are infallible, none of the `Read` functions will
-    /// return with `Err`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::{Bytes, Buf};
-    /// use std::io::Read;
-    ///
-    /// let buf = Bytes::from("hello world");
-    ///
-    /// let mut reader = buf.reader();
-    /// let mut dst = [0; 1024];
-    ///
-    /// let num = reader.read(&mut dst).unwrap();
-    ///
-    /// assert_eq!(11, num);
-    /// assert_eq!(&dst[..11], &b"hello world"[..]);
-    /// ```
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    fn reader(self) -> Reader<Self>
-    where
-        Self: Sized,
-    {
-        reader::new(self)
-    }
-}
-
-macro_rules! deref_forward_buf {
-    () => {
-        #[inline]
-        fn remaining(&self) -> usize {
-            (**self).remaining()
-        }
-
-        #[inline]
-        fn chunk(&self) -> &[u8] {
-            (**self).chunk()
-        }
-
-        #[cfg(feature = "std")]
-        #[inline]
-        fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
-            (**self).chunks_vectored(dst)
-        }
-
-        #[inline]
-        fn advance(&mut self, cnt: usize) {
-            (**self).advance(cnt)
-        }
-
-        #[inline]
-        fn has_remaining(&self) -> bool {
-            (**self).has_remaining()
-        }
-
-        #[inline]
-        fn copy_to_slice(&mut self, dst: &mut [u8]) {
-            (**self).copy_to_slice(dst)
-        }
-
-        #[inline]
-        fn get_u8(&mut self) -> u8 {
-            (**self).get_u8()
-        }
-
-        #[inline]
-        fn get_i8(&mut self) -> i8 {
-            (**self).get_i8()
-        }
-
-        #[inline]
-        fn get_u16(&mut self) -> u16 {
-            (**self).get_u16()
-        }
-
-        #[inline]
-        fn get_u16_le(&mut self) -> u16 {
-            (**self).get_u16_le()
-        }
-
-        #[inline]
-        fn get_u16_ne(&mut self) -> u16 {
-            (**self).get_u16_ne()
-        }
-
-        #[inline]
-        fn get_i16(&mut self) -> i16 {
-            (**self).get_i16()
-        }
-
-        #[inline]
-        fn get_i16_le(&mut self) -> i16 {
-            (**self).get_i16_le()
-        }
-
-        #[inline]
-        fn get_i16_ne(&mut self) -> i16 {
-            (**self).get_i16_ne()
-        }
-
-        #[inline]
-        fn get_u32(&mut self) -> u32 {
-            (**self).get_u32()
-        }
-
-        #[inline]
-        fn get_u32_le(&mut self) -> u32 {
-            (**self).get_u32_le()
-        }
-
-        #[inline]
-        fn get_u32_ne(&mut self) -> u32 {
-            (**self).get_u32_ne()
-        }
-
-        #[inline]
-        fn get_i32(&mut self) -> i32 {
-            (**self).get_i32()
-        }
-
-        #[inline]
-        fn get_i32_le(&mut self) -> i32 {
-            (**self).get_i32_le()
-        }
-
-        #[inline]
-        fn get_i32_ne(&mut self) -> i32 {
-            (**self).get_i32_ne()
-        }
-
-        #[inline]
-        fn get_u64(&mut self) -> u64 {
-            (**self).get_u64()
-        }
-
-        #[inline]
-        fn get_u64_le(&mut self) -> u64 {
-            (**self).get_u64_le()
-        }
-
-        #[inline]
-        fn get_u64_ne(&mut self) -> u64 {
-            (**self).get_u64_ne()
-        }
-
-        #[inline]
-        fn get_i64(&mut self) -> i64 {
-            (**self).get_i64()
-        }
-
-        #[inline]
-        fn get_i64_le(&mut self) -> i64 {
-            (**self).get_i64_le()
-        }
-
-        #[inline]
-        fn get_i64_ne(&mut self) -> i64 {
-            (**self).get_i64_ne()
-        }
-
-        #[inline]
-        fn get_u128(&mut self) -> u128 {
-            (**self).get_u128()
-        }
-
-        #[inline]
-        fn get_u128_le(&mut self) -> u128 {
-            (**self).get_u128_le()
-        }
-
-        #[inline]
-        fn get_u128_ne(&mut self) -> u128 {
-            (**self).get_u128_ne()
-        }
-
-        #[inline]
-        fn get_i128(&mut self) -> i128 {
-            (**self).get_i128()
-        }
-
-        #[inline]
-        fn get_i128_le(&mut self) -> i128 {
-            (**self).get_i128_le()
-        }
-
-        #[inline]
-        fn get_i128_ne(&mut self) -> i128 {
-            (**self).get_i128_ne()
-        }
-
-        #[inline]
-        fn get_uint(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint(nbytes)
-        }
-
-        #[inline]
-        fn get_uint_le(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint_le(nbytes)
-        }
-
-        #[inline]
-        fn get_uint_ne(&mut self, nbytes: usize) -> u64 {
-            (**self).get_uint_ne(nbytes)
-        }
-
-        #[inline]
-        fn get_int(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int(nbytes)
-        }
-
-        #[inline]
-        fn get_int_le(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int_le(nbytes)
-        }
-
-        #[inline]
-        fn get_int_ne(&mut self, nbytes: usize) -> i64 {
-            (**self).get_int_ne(nbytes)
-        }
-
-        #[inline]
-        fn get_f32(&mut self) -> f32 {
-            (**self).get_f32()
-        }
-
-        #[inline]
-        fn get_f32_le(&mut self) -> f32 {
-            (**self).get_f32_le()
-        }
-
-        #[inline]
-        fn get_f32_ne(&mut self) -> f32 {
-            (**self).get_f32_ne()
-        }
-
-        #[inline]
-        fn get_f64(&mut self) -> f64 {
-            (**self).get_f64()
-        }
-
-        #[inline]
-        fn get_f64_le(&mut self) -> f64 {
-            (**self).get_f64_le()
-        }
-
-        #[inline]
-        fn get_f64_ne(&mut self) -> f64 {
-            (**self).get_f64_ne()
-        }
-
-        #[inline]
-        fn try_copy_to_slice(&mut self, dst: &mut [u8]) -> Result<(), TryGetError> {
-            (**self).try_copy_to_slice(dst)
-        }
-
-        #[inline]
-        fn try_get_u8(&mut self) -> Result<u8, TryGetError> {
-            (**self).try_get_u8()
-        }
-
-        #[inline]
-        fn try_get_i8(&mut self) -> Result<i8, TryGetError> {
-            (**self).try_get_i8()
-        }
-
-        #[inline]
-        fn try_get_u16(&mut self) -> Result<u16, TryGetError> {
-            (**self).try_get_u16()
-        }
-
-        #[inline]
-        fn try_get_u16_le(&mut self) -> Result<u16, TryGetError> {
-            (**self).try_get_u16_le()
-        }
-
-        #[inline]
-        fn try_get_u16_ne(&mut self) -> Result<u16, TryGetError> {
-            (**self).try_get_u16_ne()
-        }
-
-        #[inline]
-        fn try_get_i16(&mut self) -> Result<i16, TryGetError> {
-            (**self).try_get_i16()
-        }
-
-        #[inline]
-        fn try_get_i16_le(&mut self) -> Result<i16, TryGetError> {
-            (**self).try_get_i16_le()
-        }
-
-        #[inline]
-        fn try_get_i16_ne(&mut self) -> Result<i16, TryGetError> {
-            (**self).try_get_i16_ne()
-        }
-
-        #[inline]
-        fn try_get_u32(&mut self) -> Result<u32, TryGetError> {
-            (**self).try_get_u32()
-        }
-
-        #[inline]
-        fn try_get_u32_le(&mut self) -> Result<u32, TryGetError> {
-            (**self).try_get_u32_le()
-        }
-
-        #[inline]
-        fn try_get_u32_ne(&mut self) -> Result<u32, TryGetError> {
-            (**self).try_get_u32_ne()
-        }
-
-        #[inline]
-        fn try_get_i32(&mut self) -> Result<i32, TryGetError> {
-            (**self).try_get_i32()
-        }
-
-        #[inline]
-        fn try_get_i32_le(&mut self) -> Result<i32, TryGetError> {
-            (**self).try_get_i32_le()
-        }
-
-        #[inline]
-        fn try_get_i32_ne(&mut self) -> Result<i32, TryGetError> {
-            (**self).try_get_i32_ne()
-        }
-
-        #[inline]
-        fn try_get_u64(&mut self) -> Result<u64, TryGetError> {
-            (**self).try_get_u64()
-        }
-
-        #[inline]
-        fn try_get_u64_le(&mut self) -> Result<u64, TryGetError> {
-            (**self).try_get_u64_le()
-        }
-
-        #[inline]
-        fn try_get_u64_ne(&mut self) -> Result<u64, TryGetError> {
-            (**self).try_get_u64_ne()
-        }
-
-        #[inline]
-        fn try_get_i64(&mut self) -> Result<i64, TryGetError> {
-            (**self).try_get_i64()
-        }
-
-        #[inline]
-        fn try_get_i64_le(&mut self) -> Result<i64, TryGetError> {
-            (**self).try_get_i64_le()
-        }
-
-        #[inline]
-        fn try_get_i64_ne(&mut self) -> Result<i64, TryGetError> {
-            (**self).try_get_i64_ne()
-        }
-
-        #[inline]
-        fn try_get_u128(&mut self) -> Result<u128, TryGetError> {
-            (**self).try_get_u128()
-        }
-
-        #[inline]
-        fn try_get_u128_le(&mut self) -> Result<u128, TryGetError> {
-            (**self).try_get_u128_le()
-        }
-
-        #[inline]
-        fn try_get_u128_ne(&mut self) -> Result<u128, TryGetError> {
-            (**self).try_get_u128_ne()
-        }
-
-        #[inline]
-        fn try_get_i128(&mut self) -> Result<i128, TryGetError> {
-            (**self).try_get_i128()
-        }
-
-        #[inline]
-        fn try_get_i128_le(&mut self) -> Result<i128, TryGetError> {
-            (**self).try_get_i128_le()
-        }
-
-        #[inline]
-        fn try_get_i128_ne(&mut self) -> Result<i128, TryGetError> {
-            (**self).try_get_i128_ne()
-        }
-
-        #[inline]
-        fn try_get_uint(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-            (**self).try_get_uint(nbytes)
-        }
-
-        #[inline]
-        fn try_get_uint_le(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-            (**self).try_get_uint_le(nbytes)
-        }
-
-        #[inline]
-        fn try_get_uint_ne(&mut self, nbytes: usize) -> Result<u64, TryGetError> {
-            (**self).try_get_uint_ne(nbytes)
-        }
-
-        #[inline]
-        fn try_get_int(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-            (**self).try_get_int(nbytes)
-        }
-
-        #[inline]
-        fn try_get_int_le(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-            (**self).try_get_int_le(nbytes)
-        }
-
-        #[inline]
-        fn try_get_int_ne(&mut self, nbytes: usize) -> Result<i64, TryGetError> {
-            (**self).try_get_int_ne(nbytes)
-        }
-
-        #[inline]
-        fn try_get_f32(&mut self) -> Result<f32, TryGetError> {
-            (**self).try_get_f32()
-        }
-
-        #[inline]
-        fn try_get_f32_le(&mut self) -> Result<f32, TryGetError> {
-            (**self).try_get_f32_le()
-        }
-
-        #[inline]
-        fn try_get_f32_ne(&mut self) -> Result<f32, TryGetError> {
-            (**self).try_get_f32_ne()
-        }
-
-        #[inline]
-        fn try_get_f64(&mut self) -> Result<f64, TryGetError> {
-            (**self).try_get_f64()
-        }
-
-        #[inline]
-        fn try_get_f64_le(&mut self) -> Result<f64, TryGetError> {
-            (**self).try_get_f64_le()
-        }
-
-        #[inline]
-        fn try_get_f64_ne(&mut self) -> Result<f64, TryGetError> {
-            (**self).try_get_f64_ne()
-        }
-
-        #[inline]
-        fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-            (**self).copy_to_bytes(len)
-        }
-    };
-}
-
-impl<T: Buf + ?Sized> Buf for &mut T {
-    deref_forward_buf!();
-}
-
-impl<T: Buf + ?Sized> Buf for Box<T> {
-    deref_forward_buf!();
-}
-
-impl Buf for &[u8] {
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        self
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        *self = &self[cnt..];
-    }
-
-    #[inline]
-    fn copy_to_slice(&mut self, dst: &mut [u8]) {
-        if self.len() < dst.len() {
-            panic_advance(&TryGetError {
-                requested: dst.len(),
-                available: self.len(),
-            });
-        }
-
-        dst.copy_from_slice(&self[..dst.len()]);
-        self.advance(dst.len());
-    }
-}
-
-#[cfg(feature = "std")]
-impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
-    #[inline]
-    fn remaining(&self) -> usize {
-        saturating_sub_usize_u64(self.get_ref().as_ref().len(), self.position())
-    }
-
-    #[inline]
-    fn chunk(&self) -> &[u8] {
-        let slice = self.get_ref().as_ref();
-        let pos = min_u64_usize(self.position(), slice.len());
-        &slice[pos..]
-    }
-
-    #[inline]
-    fn advance(&mut self, cnt: usize) {
-        let len = self.get_ref().as_ref().len();
-        let pos = self.position();
-
-        // We intentionally allow `cnt == 0` here even if `pos > len`.
-        let max_cnt = saturating_sub_usize_u64(len, pos);
-        if cnt > max_cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: max_cnt,
-            });
-        }
-
-        // This will not overflow because either `cnt == 0` or the sum is not
-        // greater than `len`.
-        self.set_position(pos + cnt as u64);
-    }
-}
-
-// 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) {}
diff --git a/vendor/bytes/src/buf/buf_mut.rs b/vendor/bytes/src/buf/buf_mut.rs
deleted file mode 100644
index 26645c6a..00000000
--- a/vendor/bytes/src/buf/buf_mut.rs
+++ /dev/null
@@ -1,1671 +0,0 @@
-use crate::buf::{limit, Chain, Limit, UninitSlice};
-#[cfg(feature = "std")]
-use crate::buf::{writer, Writer};
-use crate::{panic_advance, panic_does_not_fit, TryGetError};
-
-use core::{mem, ptr, usize};
-
-use alloc::{boxed::Box, vec::Vec};
-
-/// A trait for values that provide sequential write access to bytes.
-///
-/// Write bytes to a buffer
-///
-/// A buffer stores bytes in memory such that write operations are infallible.
-/// The underlying storage may or may not be in contiguous memory. A `BufMut`
-/// value is a cursor into the buffer. Writing to `BufMut` advances the cursor
-/// position.
-///
-/// The simplest `BufMut` is a `Vec<u8>`.
-///
-/// ```
-/// use bytes::BufMut;
-///
-/// let mut buf = vec![];
-///
-/// buf.put(&b"hello world"[..]);
-///
-/// assert_eq!(buf, b"hello world");
-/// ```
-pub unsafe trait BufMut {
-    /// Returns the number of bytes that can be written from the current
-    /// position until the end of the buffer is reached.
-    ///
-    /// This value is greater than or equal to the length of the slice returned
-    /// by `chunk_mut()`.
-    ///
-    /// Writing to a `BufMut` may involve allocating more memory on the fly.
-    /// Implementations may fail before reaching the number of bytes indicated
-    /// by this method if they encounter an allocation failure.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 10];
-    /// let mut buf = &mut dst[..];
-    ///
-    /// let original_remaining = buf.remaining_mut();
-    /// buf.put(&b"hello"[..]);
-    ///
-    /// assert_eq!(original_remaining - 5, buf.remaining_mut());
-    /// ```
-    ///
-    /// # Implementer notes
-    ///
-    /// Implementations of `remaining_mut` should ensure that the return value
-    /// does not change unless a call is made to `advance_mut` or any other
-    /// function that is documented to change the `BufMut`'s current position.
-    ///
-    /// # Note
-    ///
-    /// `remaining_mut` may return value smaller than actual available space.
-    fn remaining_mut(&self) -> usize;
-
-    /// Advance the internal cursor of the BufMut
-    ///
-    /// The next call to `chunk_mut` will return a slice starting `cnt` bytes
-    /// further into the underlying buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the next `cnt` bytes of `chunk` are
-    /// initialized.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = Vec::with_capacity(16);
-    ///
-    /// // Write some data
-    /// buf.chunk_mut()[0..2].copy_from_slice(b"he");
-    /// unsafe { buf.advance_mut(2) };
-    ///
-    /// // write more bytes
-    /// buf.chunk_mut()[0..3].copy_from_slice(b"llo");
-    ///
-    /// unsafe { buf.advance_mut(3); }
-    ///
-    /// assert_eq!(5, buf.len());
-    /// assert_eq!(buf, b"hello");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function **may** panic if `cnt > self.remaining_mut()`.
-    ///
-    /// # Implementer notes
-    ///
-    /// It is recommended for implementations of `advance_mut` to panic if
-    /// `cnt > self.remaining_mut()`. If the implementation does not panic,
-    /// the call must behave as if `cnt == self.remaining_mut()`.
-    ///
-    /// A call with `cnt == 0` should never panic and be a no-op.
-    unsafe fn advance_mut(&mut self, cnt: usize);
-
-    /// Returns true if there is space in `self` for more bytes.
-    ///
-    /// This is equivalent to `self.remaining_mut() != 0`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 5];
-    /// let mut buf = &mut dst[..];
-    ///
-    /// assert!(buf.has_remaining_mut());
-    ///
-    /// buf.put(&b"hello"[..]);
-    ///
-    /// assert!(!buf.has_remaining_mut());
-    /// ```
-    #[inline]
-    fn has_remaining_mut(&self) -> bool {
-        self.remaining_mut() > 0
-    }
-
-    /// Returns a mutable slice starting at the current BufMut position and of
-    /// length between 0 and `BufMut::remaining_mut()`. Note that this *can* be shorter than the
-    /// whole remainder of the buffer (this allows non-continuous implementation).
-    ///
-    /// This is a lower level function. Most operations are done with other
-    /// functions.
-    ///
-    /// The returned byte slice may represent uninitialized memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = Vec::with_capacity(16);
-    ///
-    /// unsafe {
-    ///     // MaybeUninit::as_mut_ptr
-    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'h');
-    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'e');
-    ///
-    ///     buf.advance_mut(2);
-    ///
-    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'l');
-    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'l');
-    ///     buf.chunk_mut()[2..].as_mut_ptr().write(b'o');
-    ///
-    ///     buf.advance_mut(3);
-    /// }
-    ///
-    /// assert_eq!(5, buf.len());
-    /// assert_eq!(buf, b"hello");
-    /// ```
-    ///
-    /// # Implementer notes
-    ///
-    /// This function should never panic. `chunk_mut()` should return an empty
-    /// slice **if and only if** `remaining_mut()` returns 0. In other words,
-    /// `chunk_mut()` returning an empty slice implies that `remaining_mut()` will
-    /// return 0 and `remaining_mut()` returning 0 implies that `chunk_mut()` will
-    /// return an empty slice.
-    ///
-    /// This function may trigger an out-of-memory abort if it tries to allocate
-    /// memory and fails to do so.
-    // The `chunk_mut` method was previously called `bytes_mut`. This alias makes the
-    // rename more easily discoverable.
-    #[cfg_attr(docsrs, doc(alias = "bytes_mut"))]
-    fn chunk_mut(&mut self) -> &mut UninitSlice;
-
-    /// Transfer bytes into `self` from `src` and advance the cursor by the
-    /// number of bytes written.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    ///
-    /// buf.put_u8(b'h');
-    /// buf.put(&b"ello"[..]);
-    /// buf.put(&b" world"[..]);
-    ///
-    /// assert_eq!(buf, b"hello world");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self` does not have enough capacity to contain `src`.
-    #[inline]
-    fn put<T: super::Buf>(&mut self, mut src: T)
-    where
-        Self: Sized,
-    {
-        if self.remaining_mut() < src.remaining() {
-            panic_advance(&TryGetError {
-                requested: src.remaining(),
-                available: self.remaining_mut(),
-            });
-        }
-
-        while src.has_remaining() {
-            let s = src.chunk();
-            let d = self.chunk_mut();
-            let cnt = usize::min(s.len(), d.len());
-
-            d[..cnt].copy_from_slice(&s[..cnt]);
-
-            // SAFETY: We just initialized `cnt` bytes in `self`.
-            unsafe { self.advance_mut(cnt) };
-            src.advance(cnt);
-        }
-    }
-
-    /// Transfer bytes into `self` from `src` and advance the cursor by the
-    /// number of bytes written.
-    ///
-    /// `self` must have enough remaining capacity to contain all of `src`.
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 6];
-    ///
-    /// {
-    ///     let mut buf = &mut dst[..];
-    ///     buf.put_slice(b"hello");
-    ///
-    ///     assert_eq!(1, buf.remaining_mut());
-    /// }
-    ///
-    /// assert_eq!(b"hello\0", &dst);
-    /// ```
-    #[inline]
-    fn put_slice(&mut self, mut src: &[u8]) {
-        if self.remaining_mut() < src.len() {
-            panic_advance(&TryGetError {
-                requested: src.len(),
-                available: self.remaining_mut(),
-            });
-        }
-
-        while !src.is_empty() {
-            let dst = self.chunk_mut();
-            let cnt = usize::min(src.len(), dst.len());
-
-            dst[..cnt].copy_from_slice(&src[..cnt]);
-            src = &src[cnt..];
-
-            // SAFETY: We just initialized `cnt` bytes in `self`.
-            unsafe { self.advance_mut(cnt) };
-        }
-    }
-
-    /// Put `cnt` bytes `val` into `self`.
-    ///
-    /// Logically equivalent to calling `self.put_u8(val)` `cnt` times, but may work faster.
-    ///
-    /// `self` must have at least `cnt` remaining capacity.
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut dst = [0; 6];
-    ///
-    /// {
-    ///     let mut buf = &mut dst[..];
-    ///     buf.put_bytes(b'a', 4);
-    ///
-    ///     assert_eq!(2, buf.remaining_mut());
-    /// }
-    ///
-    /// assert_eq!(b"aaaa\0\0", &dst);
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_bytes(&mut self, val: u8, mut cnt: usize) {
-        if self.remaining_mut() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.remaining_mut(),
-            })
-        }
-
-        while cnt > 0 {
-            let dst = self.chunk_mut();
-            let dst_len = usize::min(dst.len(), cnt);
-            // SAFETY: The pointer is valid for `dst_len <= dst.len()` bytes.
-            unsafe { core::ptr::write_bytes(dst.as_mut_ptr(), val, dst_len) };
-            // SAFETY: We just initialized `dst_len` bytes in `self`.
-            unsafe { self.advance_mut(dst_len) };
-            cnt -= dst_len;
-        }
-    }
-
-    /// Writes an unsigned 8 bit integer to `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u8(0x01);
-    /// assert_eq!(buf, b"\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u8(&mut self, n: u8) {
-        let src = [n];
-        self.put_slice(&src);
-    }
-
-    /// Writes a signed 8 bit integer to `self`.
-    ///
-    /// The current position is advanced by 1.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i8(0x01);
-    /// assert_eq!(buf, b"\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i8(&mut self, n: i8) {
-        let src = [n as u8];
-        self.put_slice(&src)
-    }
-
-    /// Writes an unsigned 16 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u16(0x0809);
-    /// assert_eq!(buf, b"\x08\x09");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u16(&mut self, n: u16) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 16 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u16_le(0x0809);
-    /// assert_eq!(buf, b"\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u16_le(&mut self, n: u16) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 16 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u16_ne(0x0809);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09");
-    /// } else {
-    ///     assert_eq!(buf, b"\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u16_ne(&mut self, n: u16) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 16 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i16(0x0809);
-    /// assert_eq!(buf, b"\x08\x09");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i16(&mut self, n: i16) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 16 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i16_le(0x0809);
-    /// assert_eq!(buf, b"\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i16_le(&mut self, n: i16) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 16 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 2.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i16_ne(0x0809);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09");
-    /// } else {
-    ///     assert_eq!(buf, b"\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i16_ne(&mut self, n: i16) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned 32 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u32(0x0809A0A1);
-    /// assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u32(&mut self, n: u32) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 32 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u32_le(0x0809A0A1);
-    /// assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u32_le(&mut self, n: u32) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 32 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u32_ne(0x0809A0A1);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// } else {
-    ///     assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u32_ne(&mut self, n: u32) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 32 bit integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i32(0x0809A0A1);
-    /// assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i32(&mut self, n: i32) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 32 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i32_le(0x0809A0A1);
-    /// assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i32_le(&mut self, n: i32) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 32 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i32_ne(0x0809A0A1);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x08\x09\xA0\xA1");
-    /// } else {
-    ///     assert_eq!(buf, b"\xA1\xA0\x09\x08");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i32_ne(&mut self, n: i32) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned 64 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u64(0x0102030405060708);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u64(&mut self, n: u64) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 64 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u64_le(0x0102030405060708);
-    /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u64_le(&mut self, n: u64) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 64 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u64_ne(0x0102030405060708);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// } else {
-    ///     assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u64_ne(&mut self, n: u64) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 64 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i64(0x0102030405060708);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i64(&mut self, n: i64) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 64 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i64_le(0x0102030405060708);
-    /// assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i64_le(&mut self, n: i64) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 64 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i64_ne(0x0102030405060708);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
-    /// } else {
-    ///     assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i64_ne(&mut self, n: i64) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned 128 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u128(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u128(&mut self, n: u128) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes an unsigned 128 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u128_le(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u128_le(&mut self, n: u128) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes an unsigned 128 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_u128_ne(0x01020304050607080910111213141516);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// } else {
-    ///     assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_u128_ne(&mut self, n: u128) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes a signed 128 bit integer to `self` in the big-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i128(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i128(&mut self, n: i128) {
-        self.put_slice(&n.to_be_bytes())
-    }
-
-    /// Writes a signed 128 bit integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i128_le(0x01020304050607080910111213141516);
-    /// assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i128_le(&mut self, n: i128) {
-        self.put_slice(&n.to_le_bytes())
-    }
-
-    /// Writes a signed 128 bit integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 16.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_i128_ne(0x01020304050607080910111213141516);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
-    /// } else {
-    ///     assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_i128_ne(&mut self, n: i128) {
-        self.put_slice(&n.to_ne_bytes())
-    }
-
-    /// Writes an unsigned n-byte integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_uint(0x010203, 3);
-    /// assert_eq!(buf, b"\x01\x02\x03");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_uint(&mut self, n: u64, nbytes: usize) {
-        let start = match mem::size_of_val(&n).checked_sub(nbytes) {
-            Some(start) => start,
-            None => panic_does_not_fit(nbytes, mem::size_of_val(&n)),
-        };
-
-        self.put_slice(&n.to_be_bytes()[start..]);
-    }
-
-    /// Writes an unsigned n-byte integer to `self` in the little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_uint_le(0x010203, 3);
-    /// assert_eq!(buf, b"\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_uint_le(&mut self, n: u64, nbytes: usize) {
-        let slice = n.to_le_bytes();
-        let slice = match slice.get(..nbytes) {
-            Some(slice) => slice,
-            None => panic_does_not_fit(nbytes, slice.len()),
-        };
-
-        self.put_slice(slice);
-    }
-
-    /// Writes an unsigned n-byte integer to `self` in the native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_uint_ne(0x010203, 3);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03");
-    /// } else {
-    ///     assert_eq!(buf, b"\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_uint_ne(&mut self, n: u64, nbytes: usize) {
-        if cfg!(target_endian = "big") {
-            self.put_uint(n, nbytes)
-        } else {
-            self.put_uint_le(n, nbytes)
-        }
-    }
-
-    /// Writes low `nbytes` of a signed integer to `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_int(0x0504010203, 3);
-    /// assert_eq!(buf, b"\x01\x02\x03");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_int(&mut self, n: i64, nbytes: usize) {
-        let start = match mem::size_of_val(&n).checked_sub(nbytes) {
-            Some(start) => start,
-            None => panic_does_not_fit(nbytes, mem::size_of_val(&n)),
-        };
-
-        self.put_slice(&n.to_be_bytes()[start..]);
-    }
-
-    /// Writes low `nbytes` of a signed integer to `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_int_le(0x0504010203, 3);
-    /// assert_eq!(buf, b"\x03\x02\x01");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_int_le(&mut self, n: i64, nbytes: usize) {
-        let slice = n.to_le_bytes();
-        let slice = match slice.get(..nbytes) {
-            Some(slice) => slice,
-            None => panic_does_not_fit(nbytes, slice.len()),
-        };
-
-        self.put_slice(slice);
-    }
-
-    /// Writes low `nbytes` of a signed integer to `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by `nbytes`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_int_ne(0x010203, 3);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x01\x02\x03");
-    /// } else {
-    ///     assert_eq!(buf, b"\x03\x02\x01");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self` or if `nbytes` is greater than 8.
-    #[inline]
-    fn put_int_ne(&mut self, n: i64, nbytes: usize) {
-        if cfg!(target_endian = "big") {
-            self.put_int(n, nbytes)
-        } else {
-            self.put_int_le(n, nbytes)
-        }
-    }
-
-    /// Writes an IEEE754 single-precision (4 bytes) floating point number to
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f32(1.2f32);
-    /// assert_eq!(buf, b"\x3F\x99\x99\x9A");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f32(&mut self, n: f32) {
-        self.put_u32(n.to_bits());
-    }
-
-    /// Writes an IEEE754 single-precision (4 bytes) floating point number to
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f32_le(1.2f32);
-    /// assert_eq!(buf, b"\x9A\x99\x99\x3F");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f32_le(&mut self, n: f32) {
-        self.put_u32_le(n.to_bits());
-    }
-
-    /// Writes an IEEE754 single-precision (4 bytes) floating point number to
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 4.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f32_ne(1.2f32);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x3F\x99\x99\x9A");
-    /// } else {
-    ///     assert_eq!(buf, b"\x9A\x99\x99\x3F");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f32_ne(&mut self, n: f32) {
-        self.put_u32_ne(n.to_bits());
-    }
-
-    /// Writes an IEEE754 double-precision (8 bytes) floating point number to
-    /// `self` in big-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f64(1.2f64);
-    /// assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f64(&mut self, n: f64) {
-        self.put_u64(n.to_bits());
-    }
-
-    /// Writes an IEEE754 double-precision (8 bytes) floating point number to
-    /// `self` in little-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f64_le(1.2f64);
-    /// assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f64_le(&mut self, n: f64) {
-        self.put_u64_le(n.to_bits());
-    }
-
-    /// Writes an IEEE754 double-precision (8 bytes) floating point number to
-    /// `self` in native-endian byte order.
-    ///
-    /// The current position is advanced by 8.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![];
-    /// buf.put_f64_ne(1.2f64);
-    /// if cfg!(target_endian = "big") {
-    ///     assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");
-    /// } else {
-    ///     assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");
-    /// }
-    /// ```
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is not enough remaining capacity in
-    /// `self`.
-    #[inline]
-    fn put_f64_ne(&mut self, n: f64) {
-        self.put_u64_ne(n.to_bits());
-    }
-
-    /// Creates an adaptor which can write at most `limit` bytes to `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let arr = &mut [0u8; 128][..];
-    /// assert_eq!(arr.remaining_mut(), 128);
-    ///
-    /// let dst = arr.limit(10);
-    /// assert_eq!(dst.remaining_mut(), 10);
-    /// ```
-    #[inline]
-    fn limit(self, limit: usize) -> Limit<Self>
-    where
-        Self: Sized,
-    {
-        limit::new(self, limit)
-    }
-
-    /// Creates an adaptor which implements the `Write` trait for `self`.
-    ///
-    /// This function returns a new value which implements `Write` by adapting
-    /// the `Write` trait functions to the `BufMut` trait functions. Given that
-    /// `BufMut` operations are infallible, none of the `Write` functions will
-    /// return with `Err`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    /// use std::io::Write;
-    ///
-    /// let mut buf = vec![].writer();
-    ///
-    /// let num = buf.write(&b"hello world"[..]).unwrap();
-    /// assert_eq!(11, num);
-    ///
-    /// let buf = buf.into_inner();
-    ///
-    /// assert_eq!(*buf, b"hello world"[..]);
-    /// ```
-    #[cfg(feature = "std")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-    #[inline]
-    fn writer(self) -> Writer<Self>
-    where
-        Self: Sized,
-    {
-        writer::new(self)
-    }
-
-    /// Creates an adapter which will chain this buffer with another.
-    ///
-    /// The returned `BufMut` instance will first write to all bytes from
-    /// `self`. Afterwards, it will write to `next`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut a = [0u8; 5];
-    /// let mut b = [0u8; 6];
-    ///
-    /// let mut chain = (&mut a[..]).chain_mut(&mut b[..]);
-    ///
-    /// chain.put_slice(b"hello world");
-    ///
-    /// assert_eq!(&a[..], b"hello");
-    /// assert_eq!(&b[..], b" world");
-    /// ```
-    #[inline]
-    fn chain_mut<U: BufMut>(self, next: U) -> Chain<Self, U>
-    where
-        Self: Sized,
-    {
-        Chain::new(self, next)
-    }
-}
-
-macro_rules! deref_forward_bufmut {
-    () => {
-        #[inline]
-        fn remaining_mut(&self) -> usize {
-            (**self).remaining_mut()
-        }
-
-        #[inline]
-        fn chunk_mut(&mut self) -> &mut UninitSlice {
-            (**self).chunk_mut()
-        }
-
-        #[inline]
-        unsafe fn advance_mut(&mut self, cnt: usize) {
-            (**self).advance_mut(cnt)
-        }
-
-        #[inline]
-        fn put_slice(&mut self, src: &[u8]) {
-            (**self).put_slice(src)
-        }
-
-        #[inline]
-        fn put_u8(&mut self, n: u8) {
-            (**self).put_u8(n)
-        }
-
-        #[inline]
-        fn put_i8(&mut self, n: i8) {
-            (**self).put_i8(n)
-        }
-
-        #[inline]
-        fn put_u16(&mut self, n: u16) {
-            (**self).put_u16(n)
-        }
-
-        #[inline]
-        fn put_u16_le(&mut self, n: u16) {
-            (**self).put_u16_le(n)
-        }
-
-        #[inline]
-        fn put_u16_ne(&mut self, n: u16) {
-            (**self).put_u16_ne(n)
-        }
-
-        #[inline]
-        fn put_i16(&mut self, n: i16) {
-            (**self).put_i16(n)
-        }
-
-        #[inline]
-        fn put_i16_le(&mut self, n: i16) {
-            (**self).put_i16_le(n)
-        }
-
-        #[inline]
-        fn put_i16_ne(&mut self, n: i16) {
-            (**self).put_i16_ne(n)
-        }
-
-        #[inline]
-        fn put_u32(&mut self, n: u32) {
-            (**self).put_u32(n)
-        }
-
-        #[inline]
-        fn put_u32_le(&mut self, n: u32) {
-            (**self).put_u32_le(n)
-        }
-
-        #[inline]
-        fn put_u32_ne(&mut self, n: u32) {
-            (**self).put_u32_ne(n)
-        }
-
-        #[inline]
-        fn put_i32(&mut self, n: i32) {
-            (**self).put_i32(n)
-        }
-
-        #[inline]
-        fn put_i32_le(&mut self, n: i32) {
-            (**self).put_i32_le(n)
-        }
-
-        #[inline]
-        fn put_i32_ne(&mut self, n: i32) {
-            (**self).put_i32_ne(n)
-        }
-
-        #[inline]
-        fn put_u64(&mut self, n: u64) {
-            (**self).put_u64(n)
-        }
-
-        #[inline]
-        fn put_u64_le(&mut self, n: u64) {
-            (**self).put_u64_le(n)
-        }
-
-        #[inline]
-        fn put_u64_ne(&mut self, n: u64) {
-            (**self).put_u64_ne(n)
-        }
-
-        #[inline]
-        fn put_i64(&mut self, n: i64) {
-            (**self).put_i64(n)
-        }
-
-        #[inline]
-        fn put_i64_le(&mut self, n: i64) {
-            (**self).put_i64_le(n)
-        }
-
-        #[inline]
-        fn put_i64_ne(&mut self, n: i64) {
-            (**self).put_i64_ne(n)
-        }
-    };
-}
-
-unsafe impl<T: BufMut + ?Sized> BufMut for &mut T {
-    deref_forward_bufmut!();
-}
-
-unsafe impl<T: BufMut + ?Sized> BufMut for Box<T> {
-    deref_forward_bufmut!();
-}
-
-unsafe impl BufMut for &mut [u8] {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        UninitSlice::new(self)
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // Lifetime dance taken from `impl Write for &mut [u8]`.
-        let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt);
-        *self = b;
-    }
-
-    #[inline]
-    fn put_slice(&mut self, src: &[u8]) {
-        if self.len() < src.len() {
-            panic_advance(&TryGetError {
-                requested: src.len(),
-                available: self.len(),
-            });
-        }
-
-        self[..src.len()].copy_from_slice(src);
-        // SAFETY: We just initialized `src.len()` bytes.
-        unsafe { self.advance_mut(src.len()) };
-    }
-
-    #[inline]
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // SAFETY: We just checked that the pointer is valid for `cnt` bytes.
-        unsafe {
-            ptr::write_bytes(self.as_mut_ptr(), val, cnt);
-            self.advance_mut(cnt);
-        }
-    }
-}
-
-unsafe impl BufMut for &mut [core::mem::MaybeUninit<u8>] {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        UninitSlice::uninit(self)
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // Lifetime dance taken from `impl Write for &mut [u8]`.
-        let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt);
-        *self = b;
-    }
-
-    #[inline]
-    fn put_slice(&mut self, src: &[u8]) {
-        if self.len() < src.len() {
-            panic_advance(&TryGetError {
-                requested: src.len(),
-                available: self.len(),
-            });
-        }
-
-        // SAFETY: We just checked that the pointer is valid for `src.len()` bytes.
-        unsafe {
-            ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr().cast(), src.len());
-            self.advance_mut(src.len());
-        }
-    }
-
-    #[inline]
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        if self.len() < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: self.len(),
-            });
-        }
-
-        // SAFETY: We just checked that the pointer is valid for `cnt` bytes.
-        unsafe {
-            ptr::write_bytes(self.as_mut_ptr() as *mut u8, val, cnt);
-            self.advance_mut(cnt);
-        }
-    }
-}
-
-unsafe impl BufMut for Vec<u8> {
-    #[inline]
-    fn remaining_mut(&self) -> usize {
-        // A vector can never have more than isize::MAX bytes
-        core::isize::MAX as usize - self.len()
-    }
-
-    #[inline]
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        let len = self.len();
-        let remaining = self.capacity() - len;
-
-        if remaining < cnt {
-            panic_advance(&TryGetError {
-                requested: cnt,
-                available: remaining,
-            });
-        }
-
-        // Addition will not overflow since the sum is at most the capacity.
-        self.set_len(len + cnt);
-    }
-
-    #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        if self.capacity() == self.len() {
-            self.reserve(64); // Grow the vec
-        }
-
-        let cap = self.capacity();
-        let len = self.len();
-
-        let ptr = self.as_mut_ptr();
-        // SAFETY: Since `ptr` is valid for `cap` bytes, `ptr.add(len)` must be
-        // valid for `cap - len` bytes. The subtraction will not underflow since
-        // `len <= cap`.
-        unsafe { UninitSlice::from_raw_parts_mut(ptr.add(len), cap - len) }
-    }
-
-    // Specialize these methods so they can skip checking `remaining_mut`
-    // and `advance_mut`.
-    #[inline]
-    fn put<T: super::Buf>(&mut self, mut src: T)
-    where
-        Self: Sized,
-    {
-        // In case the src isn't contiguous, reserve upfront.
-        self.reserve(src.remaining());
-
-        while src.has_remaining() {
-            let s = src.chunk();
-            let l = s.len();
-            self.extend_from_slice(s);
-            src.advance(l);
-        }
-    }
-
-    #[inline]
-    fn put_slice(&mut self, src: &[u8]) {
-        self.extend_from_slice(src);
-    }
-
-    #[inline]
-    fn put_bytes(&mut self, val: u8, cnt: usize) {
-        // If the addition overflows, then the `resize` will fail.
-        let new_len = self.len().saturating_add(cnt);
-        self.resize(new_len, val);
-    }
-}
-
-// The existence of this function makes the compiler catch if the BufMut
-// trait is "object-safe" or not.
-fn _assert_trait_object(_b: &dyn BufMut) {}
diff --git a/vendor/bytes/src/buf/chain.rs b/vendor/bytes/src/buf/chain.rs
deleted file mode 100644
index c8bc36de..00000000
--- a/vendor/bytes/src/buf/chain.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-use crate::buf::{IntoIter, UninitSlice};
-use crate::{Buf, BufMut};
-
-#[cfg(feature = "std")]
-use std::io::IoSlice;
-
-/// A `Chain` sequences two buffers.
-///
-/// `Chain` is an adapter that links two underlying buffers and provides a
-/// continuous view across both buffers. It is able to sequence either immutable
-/// buffers ([`Buf`] values) or mutable buffers ([`BufMut`] values).
-///
-/// This struct is generally created by calling [`Buf::chain`]. Please see that
-/// function's documentation for more detail.
-///
-/// # Examples
-///
-/// ```
-/// use bytes::{Bytes, Buf};
-///
-/// let mut buf = (&b"hello "[..])
-///     .chain(&b"world"[..]);
-///
-/// let full: Bytes = buf.copy_to_bytes(11);
-/// assert_eq!(full[..], b"hello world"[..]);
-/// ```
-///
-/// [`Buf::chain`]: Buf::chain
-#[derive(Debug)]
-pub struct Chain<T, U> {
-    a: T,
-    b: U,
-}
-
-impl<T, U> Chain<T, U> {
-    /// Creates a new `Chain` sequencing the provided values.
-    pub(crate) fn new(a: T, b: U) -> Chain<T, U> {
-        Chain { a, b }
-    }
-
-    /// Gets a reference to the first underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let buf = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// assert_eq!(buf.first_ref()[..], b"hello"[..]);
-    /// ```
-    pub fn first_ref(&self) -> &T {
-        &self.a
-    }
-
-    /// Gets a mutable reference to the first underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// buf.first_mut().advance(1);
-    ///
-    /// let full = buf.copy_to_bytes(9);
-    /// assert_eq!(full, b"elloworld"[..]);
-    /// ```
-    pub fn first_mut(&mut self) -> &mut T {
-        &mut self.a
-    }
-
-    /// Gets a reference to the last underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let buf = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// assert_eq!(buf.last_ref()[..], b"world"[..]);
-    /// ```
-    pub fn last_ref(&self) -> &U {
-        &self.b
-    }
-
-    /// Gets a mutable reference to the last underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = (&b"hello "[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// buf.last_mut().advance(1);
-    ///
-    /// let full = buf.copy_to_bytes(10);
-    /// assert_eq!(full, b"hello orld"[..]);
-    /// ```
-    pub fn last_mut(&mut self) -> &mut U {
-        &mut self.b
-    }
-
-    /// Consumes this `Chain`, returning the underlying values.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Buf;
-    ///
-    /// let chain = (&b"hello"[..])
-    ///     .chain(&b"world"[..]);
-    ///
-    /// let (first, last) = chain.into_inner();
-    /// assert_eq!(first[..], b"hello"[..]);
-    /// assert_eq!(last[..], b"world"[..]);
-    /// ```
-    pub fn into_inner(self) -> (T, U) {
-        (self.a, self.b)
-    }
-}
-
-impl<T, U> Buf for Chain<T, U>
-where
-    T: Buf,
-    U: Buf,
-{
-    fn remaining(&self) -> usize {
-        self.a.remaining().saturating_add(self.b.remaining())
-    }
-
-    fn chunk(&self) -> &[u8] {
-        if self.a.has_remaining() {
-            self.a.chunk()
-        } else {
-            self.b.chunk()
-        }
-    }
-
-    fn advance(&mut self, mut cnt: usize) {
-        let a_rem = self.a.remaining();
-
-        if a_rem != 0 {
-            if a_rem >= cnt {
-                self.a.advance(cnt);
-                return;
-            }
-
-            // Consume what is left of a
-            self.a.advance(a_rem);
-
-            cnt -= a_rem;
-        }
-
-        self.b.advance(cnt);
-    }
-
-    #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        let mut n = self.a.chunks_vectored(dst);
-        n += self.b.chunks_vectored(&mut dst[n..]);
-        n
-    }
-
-    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-        let a_rem = self.a.remaining();
-        if a_rem >= len {
-            self.a.copy_to_bytes(len)
-        } else if a_rem == 0 {
-            self.b.copy_to_bytes(len)
-        } else {
-            assert!(
-                len - a_rem <= self.b.remaining(),
-                "`len` greater than remaining"
-            );
-            let mut ret = crate::BytesMut::with_capacity(len);
-            ret.put(&mut self.a);
-            ret.put((&mut self.b).take(len - a_rem));
-            ret.freeze()
-        }
-    }
-}
-
-unsafe impl<T, U> BufMut for Chain<T, U>
-where
-    T: BufMut,
-    U: BufMut,
-{
-    fn remaining_mut(&self) -> usize {
-        self.a
-            .remaining_mut()
-            .saturating_add(self.b.remaining_mut())
-    }
-
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        if self.a.has_remaining_mut() {
-            self.a.chunk_mut()
-        } else {
-            self.b.chunk_mut()
-        }
-    }
-
-    unsafe fn advance_mut(&mut self, mut cnt: usize) {
-        let a_rem = self.a.remaining_mut();
-
-        if a_rem != 0 {
-            if a_rem >= cnt {
-                self.a.advance_mut(cnt);
-                return;
-            }
-
-            // Consume what is left of a
-            self.a.advance_mut(a_rem);
-
-            cnt -= a_rem;
-        }
-
-        self.b.advance_mut(cnt);
-    }
-}
-
-impl<T, U> IntoIterator for Chain<T, U>
-where
-    T: Buf,
-    U: Buf,
-{
-    type Item = u8;
-    type IntoIter = IntoIter<Chain<T, U>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter::new(self)
-    }
-}
diff --git a/vendor/bytes/src/buf/iter.rs b/vendor/bytes/src/buf/iter.rs
deleted file mode 100644
index 74f9b991..00000000
--- a/vendor/bytes/src/buf/iter.rs
+++ /dev/null
@@ -1,127 +0,0 @@
-use crate::Buf;
-
-/// Iterator over the bytes contained by the buffer.
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```
-/// use bytes::Bytes;
-///
-/// let buf = Bytes::from(&b"abc"[..]);
-/// let mut iter = buf.into_iter();
-///
-/// assert_eq!(iter.next(), Some(b'a'));
-/// assert_eq!(iter.next(), Some(b'b'));
-/// assert_eq!(iter.next(), Some(b'c'));
-/// assert_eq!(iter.next(), None);
-/// ```
-#[derive(Debug)]
-pub struct IntoIter<T> {
-    inner: T,
-}
-
-impl<T> IntoIter<T> {
-    /// Creates an iterator over the bytes contained by the buffer.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::Bytes;
-    ///
-    /// let buf = Bytes::from_static(b"abc");
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    /// assert_eq!(iter.next(), Some(b'b'));
-    /// assert_eq!(iter.next(), Some(b'c'));
-    /// assert_eq!(iter.next(), None);
-    /// ```
-    pub fn new(inner: T) -> IntoIter<T> {
-        IntoIter { inner }
-    }
-
-    /// Consumes this `IntoIter`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, Bytes};
-    ///
-    /// let buf = Bytes::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// let buf = iter.into_inner();
-    /// assert_eq!(2, buf.remaining());
-    /// ```
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, Bytes};
-    ///
-    /// let buf = Bytes::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// assert_eq!(2, iter.get_ref().remaining());
-    /// ```
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BytesMut};
-    ///
-    /// let buf = BytesMut::from(&b"abc"[..]);
-    /// let mut iter = buf.into_iter();
-    ///
-    /// assert_eq!(iter.next(), Some(b'a'));
-    ///
-    /// iter.get_mut().advance(1);
-    ///
-    /// assert_eq!(iter.next(), Some(b'c'));
-    /// ```
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-}
-
-impl<T: Buf> Iterator for IntoIter<T> {
-    type Item = u8;
-
-    fn next(&mut self) -> Option<u8> {
-        if !self.inner.has_remaining() {
-            return None;
-        }
-
-        let b = self.inner.chunk()[0];
-        self.inner.advance(1);
-
-        Some(b)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let rem = self.inner.remaining();
-        (rem, Some(rem))
-    }
-}
-
-impl<T: Buf> ExactSizeIterator for IntoIter<T> {}
diff --git a/vendor/bytes/src/buf/limit.rs b/vendor/bytes/src/buf/limit.rs
deleted file mode 100644
index b422be53..00000000
--- a/vendor/bytes/src/buf/limit.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use crate::buf::UninitSlice;
-use crate::BufMut;
-
-use core::cmp;
-
-/// A `BufMut` adapter which limits the amount of bytes that can be written
-/// to an underlying buffer.
-#[derive(Debug)]
-pub struct Limit<T> {
-    inner: T,
-    limit: usize,
-}
-
-pub(super) fn new<T>(inner: T, limit: usize) -> Limit<T> {
-    Limit { inner, limit }
-}
-
-impl<T> Limit<T> {
-    /// Consumes this `Limit`, returning the underlying value.
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-
-    /// Returns the maximum number of bytes that can be written
-    ///
-    /// # Note
-    ///
-    /// If the inner `BufMut` has fewer bytes than indicated by this method then
-    /// that is the actual number of available bytes.
-    pub fn limit(&self) -> usize {
-        self.limit
-    }
-
-    /// Sets the maximum number of bytes that can be written.
-    ///
-    /// # Note
-    ///
-    /// If the inner `BufMut` has fewer bytes than `lim` then that is the actual
-    /// number of available bytes.
-    pub fn set_limit(&mut self, lim: usize) {
-        self.limit = lim
-    }
-}
-
-unsafe impl<T: BufMut> BufMut for Limit<T> {
-    fn remaining_mut(&self) -> usize {
-        cmp::min(self.inner.remaining_mut(), self.limit)
-    }
-
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
-        let bytes = self.inner.chunk_mut();
-        let end = cmp::min(bytes.len(), self.limit);
-        &mut bytes[..end]
-    }
-
-    unsafe fn advance_mut(&mut self, cnt: usize) {
-        assert!(cnt <= self.limit);
-        self.inner.advance_mut(cnt);
-        self.limit -= cnt;
-    }
-}
diff --git a/vendor/bytes/src/buf/mod.rs b/vendor/bytes/src/buf/mod.rs
deleted file mode 100644
index 1bf0a47e..00000000
--- a/vendor/bytes/src/buf/mod.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Utilities for working with buffers.
-//!
-//! A buffer is any structure that contains a sequence of bytes. The bytes may
-//! or may not be stored in contiguous memory. This module contains traits used
-//! to abstract over buffers as well as utilities for working with buffer types.
-//!
-//! # `Buf`, `BufMut`
-//!
-//! These are the two foundational traits for abstractly working with buffers.
-//! They can be thought as iterators for byte structures. They offer additional
-//! performance over `Iterator` by providing an API optimized for byte slices.
-//!
-//! See [`Buf`] and [`BufMut`] for more details.
-//!
-//! [rope]: https://en.wikipedia.org/wiki/Rope_(data_structure)
-
-mod buf_impl;
-mod buf_mut;
-mod chain;
-mod iter;
-mod limit;
-#[cfg(feature = "std")]
-mod reader;
-mod take;
-mod uninit_slice;
-mod vec_deque;
-#[cfg(feature = "std")]
-mod writer;
-
-pub use self::buf_impl::Buf;
-pub use self::buf_mut::BufMut;
-pub use self::chain::Chain;
-pub use self::iter::IntoIter;
-pub use self::limit::Limit;
-pub use self::take::Take;
-pub use self::uninit_slice::UninitSlice;
-
-#[cfg(feature = "std")]
-pub use self::{reader::Reader, writer::Writer};
diff --git a/vendor/bytes/src/buf/reader.rs b/vendor/bytes/src/buf/reader.rs
deleted file mode 100644
index 52149495..00000000
--- a/vendor/bytes/src/buf/reader.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use crate::Buf;
-
-use std::{cmp, io};
-
-/// A `Buf` adapter which implements `io::Read` for the inner value.
-///
-/// This struct is generally created by calling `reader()` on `Buf`. See
-/// documentation of [`reader()`](Buf::reader) for more
-/// details.
-#[derive(Debug)]
-pub struct Reader<B> {
-    buf: B,
-}
-
-pub fn new<B>(buf: B) -> Reader<B> {
-    Reader { buf }
-}
-
-impl<B: Buf> Reader<B> {
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    ///
-    /// let buf = b"hello world".reader();
-    ///
-    /// assert_eq!(b"hello world", buf.get_ref());
-    /// ```
-    pub fn get_ref(&self) -> &B {
-        &self.buf
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    pub fn get_mut(&mut self) -> &mut B {
-        &mut self.buf
-    }
-
-    /// Consumes this `Reader`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    /// use std::io;
-    ///
-    /// let mut buf = b"hello world".reader();
-    /// let mut dst = vec![];
-    ///
-    /// io::copy(&mut buf, &mut dst).unwrap();
-    ///
-    /// let buf = buf.into_inner();
-    /// assert_eq!(0, buf.remaining());
-    /// ```
-    pub fn into_inner(self) -> B {
-        self.buf
-    }
-}
-
-impl<B: Buf + Sized> io::Read for Reader<B> {
-    fn read(&mut self, dst: &mut [u8]) -> io::Result<usize> {
-        let len = cmp::min(self.buf.remaining(), dst.len());
-
-        Buf::copy_to_slice(&mut self.buf, &mut dst[0..len]);
-        Ok(len)
-    }
-}
-
-impl<B: Buf + Sized> io::BufRead for Reader<B> {
-    fn fill_buf(&mut self) -> io::Result<&[u8]> {
-        Ok(self.buf.chunk())
-    }
-    fn consume(&mut self, amt: usize) {
-        self.buf.advance(amt)
-    }
-}
diff --git a/vendor/bytes/src/buf/take.rs b/vendor/bytes/src/buf/take.rs
deleted file mode 100644
index acfeef6e..00000000
--- a/vendor/bytes/src/buf/take.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-use crate::Buf;
-
-use core::cmp;
-
-#[cfg(feature = "std")]
-use std::io::IoSlice;
-
-/// A `Buf` adapter which limits the bytes read from an underlying buffer.
-///
-/// This struct is generally created by calling `take()` on `Buf`. See
-/// documentation of [`take()`](Buf::take) for more details.
-#[derive(Debug)]
-pub struct Take<T> {
-    inner: T,
-    limit: usize,
-}
-
-pub fn new<T>(inner: T, limit: usize) -> Take<T> {
-    Take { inner, limit }
-}
-
-impl<T> Take<T> {
-    /// Consumes this `Take`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world".take(2);
-    /// let mut dst = vec![];
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"he"[..]);
-    ///
-    /// let mut buf = buf.into_inner();
-    ///
-    /// dst.clear();
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"llo world"[..]);
-    /// ```
-    pub fn into_inner(self) -> T {
-        self.inner
-    }
-
-    /// Gets a reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    ///
-    /// let buf = b"hello world".take(2);
-    ///
-    /// assert_eq!(11, buf.get_ref().remaining());
-    /// ```
-    pub fn get_ref(&self) -> &T {
-        &self.inner
-    }
-
-    /// Gets a mutable reference to the underlying `Buf`.
-    ///
-    /// It is inadvisable to directly read from the underlying `Buf`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world".take(2);
-    /// let mut dst = vec![];
-    ///
-    /// buf.get_mut().advance(2);
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"ll"[..]);
-    /// ```
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.inner
-    }
-
-    /// Returns the maximum number of bytes that can be read.
-    ///
-    /// # Note
-    ///
-    /// If the inner `Buf` has fewer bytes than indicated by this method then
-    /// that is the actual number of available bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::Buf;
-    ///
-    /// let mut buf = b"hello world".take(2);
-    ///
-    /// assert_eq!(2, buf.limit());
-    /// assert_eq!(b'h', buf.get_u8());
-    /// assert_eq!(1, buf.limit());
-    /// ```
-    pub fn limit(&self) -> usize {
-        self.limit
-    }
-
-    /// Sets the maximum number of bytes that can be read.
-    ///
-    /// # Note
-    ///
-    /// If the inner `Buf` has fewer bytes than `lim` then that is the actual
-    /// number of available bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::{Buf, BufMut};
-    ///
-    /// let mut buf = b"hello world".take(2);
-    /// let mut dst = vec![];
-    ///
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"he"[..]);
-    ///
-    /// dst.clear();
-    ///
-    /// buf.set_limit(3);
-    /// dst.put(&mut buf);
-    /// assert_eq!(*dst, b"llo"[..]);
-    /// ```
-    pub fn set_limit(&mut self, lim: usize) {
-        self.limit = lim
-    }
-}
-
-impl<T: Buf> Buf for Take<T> {
-    fn remaining(&self) -> usize {
-        cmp::min(self.inner.remaining(), self.limit)
-    }
-
-    fn chunk(&self) -> &[u8] {
-        let bytes = self.inner.chunk();
-        &bytes[..cmp::min(bytes.len(), self.limit)]
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        assert!(cnt <= self.limit);
-        self.inner.advance(cnt);
-        self.limit -= cnt;
-    }
-
-    fn copy_to_bytes(&mut self, len: usize) -> crate::Bytes {
-        assert!(len <= self.remaining(), "`len` greater than remaining");
-
-        let r = self.inner.copy_to_bytes(len);
-        self.limit -= len;
-        r
-    }
-
-    #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        if self.limit == 0 {
-            return 0;
-        }
-
-        const LEN: usize = 16;
-        let mut slices: [IoSlice<'a>; LEN] = [
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-            IoSlice::new(&[]),
-        ];
-
-        let cnt = self
-            .inner
-            .chunks_vectored(&mut slices[..dst.len().min(LEN)]);
-        let mut limit = self.limit;
-        for (i, (dst, slice)) in dst[..cnt].iter_mut().zip(slices.iter()).enumerate() {
-            if let Some(buf) = slice.get(..limit) {
-                // SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV.
-                let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(buf) };
-                *dst = IoSlice::new(buf);
-                return i + 1;
-            } else {
-                // SAFETY: We could do this safely with `IoSlice::advance` if we had a larger MSRV.
-                let buf = unsafe { std::mem::transmute::<&[u8], &'a [u8]>(slice) };
-                *dst = IoSlice::new(buf);
-                limit -= slice.len();
-            }
-        }
-        cnt
-    }
-}
diff --git a/vendor/bytes/src/buf/uninit_slice.rs b/vendor/bytes/src/buf/uninit_slice.rs
deleted file mode 100644
index aea096ae..00000000
--- a/vendor/bytes/src/buf/uninit_slice.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-use core::fmt;
-use core::mem::MaybeUninit;
-use core::ops::{
-    Index, IndexMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
-};
-
-/// Uninitialized byte slice.
-///
-/// Returned by `BufMut::chunk_mut()`, the referenced byte slice may be
-/// uninitialized. The wrapper provides safe access without introducing
-/// undefined behavior.
-///
-/// The safety invariants of this wrapper are:
-///
-///  1. Reading from an `UninitSlice` is undefined behavior.
-///  2. Writing uninitialized bytes to an `UninitSlice` is undefined behavior.
-///
-/// The difference between `&mut UninitSlice` and `&mut [MaybeUninit<u8>]` is
-/// that it is possible in safe code to write uninitialized bytes to an
-/// `&mut [MaybeUninit<u8>]`, which this type prohibits.
-#[repr(transparent)]
-pub struct UninitSlice([MaybeUninit<u8>]);
-
-impl UninitSlice {
-    /// Creates a `&mut UninitSlice` wrapping a slice of initialised memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut buffer = [0u8; 64];
-    /// let slice = UninitSlice::new(&mut buffer[..]);
-    /// ```
-    #[inline]
-    pub fn new(slice: &mut [u8]) -> &mut UninitSlice {
-        unsafe { &mut *(slice as *mut [u8] as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
-    }
-
-    /// Creates a `&mut UninitSlice` wrapping a slice of uninitialised memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    /// use core::mem::MaybeUninit;
-    ///
-    /// let mut buffer = [MaybeUninit::uninit(); 64];
-    /// let slice = UninitSlice::uninit(&mut buffer[..]);
-    ///
-    /// let mut vec = Vec::with_capacity(1024);
-    /// let spare: &mut UninitSlice = vec.spare_capacity_mut().into();
-    /// ```
-    #[inline]
-    pub fn uninit(slice: &mut [MaybeUninit<u8>]) -> &mut UninitSlice {
-        unsafe { &mut *(slice as *mut [MaybeUninit<u8>] as *mut UninitSlice) }
-    }
-
-    fn uninit_ref(slice: &[MaybeUninit<u8>]) -> &UninitSlice {
-        unsafe { &*(slice as *const [MaybeUninit<u8>] as *const UninitSlice) }
-    }
-
-    /// Create a `&mut UninitSlice` from a pointer and a length.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that `ptr` references a valid memory region owned
-    /// by the caller representing a byte slice for the duration of `'a`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let bytes = b"hello world".to_vec();
-    /// let ptr = bytes.as_ptr() as *mut _;
-    /// let len = bytes.len();
-    ///
-    /// let slice = unsafe { UninitSlice::from_raw_parts_mut(ptr, len) };
-    /// ```
-    #[inline]
-    pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
-        let maybe_init: &mut [MaybeUninit<u8>] =
-            core::slice::from_raw_parts_mut(ptr as *mut _, len);
-        Self::uninit(maybe_init)
-    }
-
-    /// Write a single byte at the specified offset.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if `index` is out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut data = [b'f', b'o', b'o'];
-    /// let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
-    ///
-    /// slice.write_byte(0, b'b');
-    ///
-    /// assert_eq!(b"boo", &data[..]);
-    /// ```
-    #[inline]
-    pub fn write_byte(&mut self, index: usize, byte: u8) {
-        assert!(index < self.len());
-
-        unsafe { self[index..].as_mut_ptr().write(byte) }
-    }
-
-    /// Copies bytes from `src` into `self`.
-    ///
-    /// The length of `src` must be the same as `self`.
-    ///
-    /// # Panics
-    ///
-    /// The function panics if `src` has a different length than `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::buf::UninitSlice;
-    ///
-    /// let mut data = [b'f', b'o', b'o'];
-    /// let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
-    ///
-    /// slice.copy_from_slice(b"bar");
-    ///
-    /// assert_eq!(b"bar", &data[..]);
-    /// ```
-    #[inline]
-    pub fn copy_from_slice(&mut self, src: &[u8]) {
-        use core::ptr;
-
-        assert_eq!(self.len(), src.len());
-
-        unsafe {
-            ptr::copy_nonoverlapping(src.as_ptr(), self.as_mut_ptr(), self.len());
-        }
-    }
-
-    /// Return a raw pointer to the slice's buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller **must not** read from the referenced memory and **must not**
-    /// write **uninitialized** bytes to the slice either.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// let ptr = BufMut::chunk_mut(&mut slice).as_mut_ptr();
-    /// ```
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.0.as_mut_ptr() as *mut _
-    }
-
-    /// Return a `&mut [MaybeUninit<u8>]` to this slice's buffer.
-    ///
-    /// # Safety
-    ///
-    /// The caller **must not** read from the referenced memory and **must not** write
-    /// **uninitialized** bytes to the slice either. This is because `BufMut` implementation
-    /// that created the `UninitSlice` knows which parts are initialized. Writing uninitialized
-    /// bytes to the slice may cause the `BufMut` to read those bytes and trigger undefined
-    /// behavior.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// unsafe {
-    ///     let uninit_slice = BufMut::chunk_mut(&mut slice).as_uninit_slice_mut();
-    /// };
-    /// ```
-    #[inline]
-    pub unsafe fn as_uninit_slice_mut(&mut self) -> &mut [MaybeUninit<u8>] {
-        &mut self.0
-    }
-
-    /// Returns the number of bytes in the slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use bytes::BufMut;
-    ///
-    /// let mut data = [0, 1, 2];
-    /// let mut slice = &mut data[..];
-    /// let len = BufMut::chunk_mut(&mut slice).len();
-    ///
-    /// assert_eq!(len, 3);
-    /// ```
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-}
-
-impl fmt::Debug for UninitSlice {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("UninitSlice[...]").finish()
-    }
-}
-
-impl<'a> From<&'a mut [u8]> for &'a mut UninitSlice {
-    fn from(slice: &'a mut [u8]) -> Self {
-        UninitSlice::new(slice)
-    }
-}
-
-impl<'a> From<&'a mut [MaybeUninit<u8>]> for &'a mut UninitSlice {
-    fn from(slice: &'a mut [MaybeUninit<u8>]) -> Self {
-        UninitSlice::uninit(slice)
-    }
-}
-
-macro_rules! impl_index {
-    ($($t:ty),*) => {
-        $(
-            impl Index<$t> for UninitSlice {
-                type Output = UninitSlice;
-
-                #[inline]
-                fn index(&self, index: $t) -> &UninitSlice {
-                    UninitSlice::uninit_ref(&self.0[index])
-                }
-            }
-
-            impl IndexMut<$t> for UninitSlice {
-                #[inline]
-                fn index_mut(&mut self, index: $t) -> &mut UninitSlice {
-                    UninitSlice::uninit(&mut self.0[index])
-                }
-            }
-        )*
-    };
-}
-
-impl_index!(
-    Range<usize>,
-    RangeFrom<usize>,
-    RangeFull,
-    RangeInclusive<usize>,
-    RangeTo<usize>,
-    RangeToInclusive<usize>
-);
diff --git a/vendor/bytes/src/buf/vec_deque.rs b/vendor/bytes/src/buf/vec_deque.rs
deleted file mode 100644
index 55d5636b..00000000
--- a/vendor/bytes/src/buf/vec_deque.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-use alloc::collections::VecDeque;
-#[cfg(feature = "std")]
-use std::io;
-
-use super::Buf;
-
-impl Buf for VecDeque<u8> {
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    fn chunk(&self) -> &[u8] {
-        let (s1, s2) = self.as_slices();
-        if s1.is_empty() {
-            s2
-        } else {
-            s1
-        }
-    }
-
-    #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [io::IoSlice<'a>]) -> usize {
-        if self.is_empty() || dst.is_empty() {
-            return 0;
-        }
-
-        let (s1, s2) = self.as_slices();
-        dst[0] = io::IoSlice::new(s1);
-        if s2.is_empty() || dst.len() == 1 {
-            return 1;
-        }
-
-        dst[1] = io::IoSlice::new(s2);
-        2
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        self.drain(..cnt);
-    }
-}
diff --git a/vendor/bytes/src/buf/writer.rs b/vendor/bytes/src/buf/writer.rs
deleted file mode 100644
index e72348f4..00000000
--- a/vendor/bytes/src/buf/writer.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use crate::BufMut;
-
-use std::{cmp, io};
-
-/// A `BufMut` adapter which implements `io::Write` for the inner value.
-///
-/// This struct is generally created by calling `writer()` on `BufMut`. See
-/// documentation of [`writer()`](BufMut::writer) for more
-/// details.
-#[derive(Debug)]
-pub struct Writer<B> {
-    buf: B,
-}
-
-pub fn new<B>(buf: B) -> Writer<B> {
-    Writer { buf }
-}
-
-impl<B: BufMut> Writer<B> {
-    /// Gets a reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::BufMut;
-    ///
-    /// let buf = Vec::with_capacity(1024).writer();
-    ///
-    /// assert_eq!(1024, buf.get_ref().capacity());
-    /// ```
-    pub fn get_ref(&self) -> &B {
-        &self.buf
-    }
-
-    /// Gets a mutable reference to the underlying `BufMut`.
-    ///
-    /// It is inadvisable to directly write to the underlying `BufMut`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::BufMut;
-    ///
-    /// let mut buf = vec![].writer();
-    ///
-    /// buf.get_mut().reserve(1024);
-    ///
-    /// assert_eq!(1024, buf.get_ref().capacity());
-    /// ```
-    pub fn get_mut(&mut self) -> &mut B {
-        &mut self.buf
-    }
-
-    /// Consumes this `Writer`, returning the underlying value.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use bytes::BufMut;
-    /// use std::io;
-    ///
-    /// let mut buf = vec![].writer();
-    /// let mut src = &b"hello world"[..];
-    ///
-    /// io::copy(&mut src, &mut buf).unwrap();
-    ///
-    /// let buf = buf.into_inner();
-    /// assert_eq!(*buf, b"hello world"[..]);
-    /// ```
-    pub fn into_inner(self) -> B {
-        self.buf
-    }
-}
-
-impl<B: BufMut + Sized> io::Write for Writer<B> {
-    fn write(&mut self, src: &[u8]) -> io::Result<usize> {
-        let n = cmp::min(self.buf.remaining_mut(), src.len());
-
-        self.buf.put_slice(&src[..n]);
-        Ok(n)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}