适配器

    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
    }

bytes = "=1.12.1"

use std::io::IoSlice;
use std::panic;

use bytes::{Buf, Bytes};

// 错误写法：以为 chunk() 就是全部数据
fn find_crlf_buggy(buf: &impl Buf) -> Option<usize> {
  buf.chunk().windows(2).position(|w| w == b"\r\n")
}

// 错误写法：直接从 chunk() 里切 4 个字节当长度前缀
fn frame_len_buggy(buf: &impl Buf) -> u32 {
  u32::from_be_bytes(buf.chunk()[..4].try_into().unwrap())
}

fn main() {
  panic::set_hook(Box::new(|info| println!("panicked: {}", info.payload_as_str().unwrap_or("?"))));

  // 一行请求在两次 read 之间被切开
  let buf = Bytes::from_static(b"GET / HT").chain(Bytes::from_static(b"TP/1.1\r\nHost: a\r\n"));
  println!("remaining = {}, chunk = {:?}", buf.remaining(), Bytes::copy_from_slice(buf.chunk()));
  println!("find_crlf_buggy = {:?}", find_crlf_buggy(&buf));

  let mut slices = [IoSlice::new(&[]); 4];
  let n = buf.chunks_vectored(&mut slices);
  println!("chunks_vectored filled {n}: {:?}", slices[..n].iter().map(|s| s.len()).collect::<Vec<_>>());

  // 长度前缀被切在 2 + 2
  let mut frame = Bytes::from_static(&[0, 0]).chain(Bytes::from_static(&[0, 5, b'h', b'e', b'l', b'l', b'o']));
  let r = panic::catch_unwind(|| frame_len_buggy(&frame));
  println!("frame_len_buggy ok = {}", r.is_ok());
  println!("get_u32 = {}", frame.get_u32());
  println!("rest = {:?}", frame.copy_to_bytes(5));
}

remaining = 25, chunk = b"GET / HT"
find_crlf_buggy = None
chunks_vectored filled 2: [8, 17]
panicked: range end index 4 out of range for slice of length 2
frame_len_buggy ok = false
get_u32 = 5
rest = b"hello"

    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()
        }
    }

use bytes::{Buf, Bytes};

fn main() {
  let a = Bytes::from(b"hello ".to_vec());
  let b = Bytes::from(b"world".to_vec());
  let (pa, pb) = (a.as_ptr(), b.as_ptr());
  let mut c = a.chain(b);
  let x = c.copy_to_bytes(3); // 全在 a 里
  println!("within a: {:?} shares a: {}", x, x.as_ptr() == pa);
  let y = c.copy_to_bytes(5); // 跨过 a、b 的边界
  println!("across:   {:?} shares a: {} shares b: {}", y, y.as_ptr() == pa.wrapping_add(3), y.as_ptr() == pb);
  let z = c.copy_to_bytes(3); // a 已读完，全在 b 里
  println!("within b: {:?} shares b: {}", z, z.as_ptr() == pb.wrapping_add(2));
}

within a: b"hel" shares a: true
across:   b"lo wo" shares a: false shares b: false
within b: b"rld" shares b: true

    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(&[]); LEN];

        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
    }

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;
    }
}

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)
    }
}

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(())
    }
}

use std::io::{self, BufRead, Read, Write};

use bytes::{Buf, BufMut, Bytes, BytesMut};

fn main() {
  println!("== Writer");
  let mut w = BytesMut::new().limit(8).writer();
  let n = w.write(b"0123456789").unwrap();
  println!("  write returned {n}");
  let e = w.write_all(b"xyz").unwrap_err();
  println!("  write_all: {:?} {}", e.kind(), e);
  println!("  inner = {:?}", w.get_ref().get_ref());

  println!("== Reader");
  let mut r = Bytes::from_static(b"line one\nli").chain(Bytes::from_static(b"ne two\n")).reader();
  println!("  fill_buf = {:?}", Bytes::copy_from_slice(r.fill_buf().unwrap()));
  let mut s = String::new();
  r.read_line(&mut s).unwrap();
  r.read_line(&mut s).unwrap();
  println!("  two read_line = {s:?}");
  let mut rest = Vec::new();
  let n = r.read_to_end(&mut rest).unwrap();
  println!("  read_to_end = {n}");

  println!("== io::copy Reader -> Writer");
  let mut src = Bytes::from_static(b"abc").chain(Bytes::from_static(b"def")).reader();
  let mut dst = BytesMut::new().writer();
  let n = io::copy(&mut src, &mut dst).unwrap();
  println!("  copied {n}: {:?}", dst.into_inner());
}

== Writer
  write returned 8
  write_all: WriteZero failed to write whole buffer
  inner = b"01234567"
== Reader
  fill_buf = b"line one\nli"
  two read_line = "line one\nline two\n"
  read_to_end = 0
== io::copy Reader -> Writer
  copied 6: b"abcdef"

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))
    }
}

use bytes::{Buf, Bytes};

fn main() {
  let it = Bytes::from_static(b"ab").chain(Bytes::from_static(b"cd")).into_iter();
  println!("size_hint {:?}", it.size_hint());
  println!("collect {:?}", it.map(|b| b as char).collect::<String>());

  let b = Bytes::from_static(b"xy");
  let by_ref: Vec<&u8> = (&b).into_iter().collect();
  println!("&Bytes -> {by_ref:?}");
  let by_val: Vec<u8> = b.into_iter().collect();
  println!("Bytes  -> {by_val:?}");
}

size_hint (4, Some(4))
collect "abcd"
&Bytes -> [120, 121]
Bytes  -> [120, 121]

== Take
  remaining 5 chunk b"abc"
  chunks_vectored 2: [3, 2]
  after advance(4): remaining 1 limit 1 inner remaining 4
  panicked: assertion failed: cnt <= self.limit
  advance(2) ok = false
== Limit
  remaining_mut 4
  chunk_mut len 4 (inner cap now 64)
  panicked: advance out of bounds: the len is 4 but advancing by 5
  put_slice(5 bytes) ok = false
  after put_slice(4): [49, 50, 51, 52] remaining_mut 0