Revert "[git-packetline] get it to compile by resorting to another buffer"

This reverts commit 01e15c8.

Author: Byron

git-packetline/src/read/sidebands/async_io.rs

@@ -1,7 +1,7 @@
 use crate::{
     decode,
     immutable::{Band, Text},
-    PacketLine, StreamingPeekableIter, MAX_DATA_LEN,
+    PacketLine, StreamingPeekableIter, U16_HEX_BYTES,
 };
 use futures_io::{AsyncBufRead, AsyncRead};
 use futures_lite::ready;
@@ -24,7 +24,6 @@ where
     parent: Option<&'a mut StreamingPeekableIter<T>>,
     handle_progress: Option<F>,
     read_line: Option<Pin<Box<dyn Future<Output = ReadLineResult<'a>> + 'a>>>,
-    buf: Vec<u8>,
     pos: usize,
     cap: usize,
 }
@@ -50,7 +49,6 @@ where
             parent: Some(parent),
             handle_progress: None,
             read_line: None,
-            buf: Vec::with_capacity(MAX_DATA_LEN),
             pos: 0,
             cap: 0,
         }
@@ -71,7 +69,6 @@ where
             parent: Some(parent),
             handle_progress: Some(handle_progress),
             read_line: None,
-            buf: Vec::with_capacity(MAX_DATA_LEN),
             pos: 0,
             cap: 0,
         }
@@ -83,7 +80,6 @@ where
             parent: Some(parent),
             handle_progress: None,
             read_line: None,
-            buf: Vec::with_capacity(MAX_DATA_LEN),
             pos: 0,
             cap: 0,
         }
@@ -123,52 +119,51 @@ where
 {
     fn poll_fill_buf(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<&[u8]>> {
         use futures_lite::FutureExt;
-        use std::{io, io::Read};
-        {
-            let this = self.as_mut().get_mut();
-            if this.pos >= this.cap {
-                this.cap = loop {
-                    // todo!("poll a future based on a field of ourselves - self-ref once again");
-                    this.read_line = Some(this.parent.take().unwrap().read_line().boxed());
-                    let line = match ready!(this.read_line.as_mut().expect("set above").poll(_cx)) {
-                        Some(line) => line?.map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,
-                        None => break 0,
-                    };
-                    match this.handle_progress.as_mut() {
-                        Some(handle_progress) => {
-                            let mut band = line
-                                .decode_band()
-                                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-                            match band {
-                                Band::Data(ref mut d) => break d.read(&mut this.buf)?,
-                                Band::Progress(d) => {
-                                    let text = Text::from(d).0;
-                                    handle_progress(false, text);
-                                }
-                                Band::Error(d) => {
-                                    let text = Text::from(d).0;
-                                    handle_progress(true, text);
-                                }
-                            };
-                        }
-                        None => {
-                            break match line.as_slice() {
-                                Some(ref mut d) => d.read(&mut this.buf)?,
-                                None => {
-                                    return Poll::Ready(Err(io::Error::new(
-                                        io::ErrorKind::UnexpectedEof,
-                                        "encountered non-data line in a data-line only context",
-                                    )))
-                                }
+        use std::io;
+        let this = self.as_mut().get_mut();
+        if this.pos >= this.cap {
+            let (ofs, cap) = loop {
+                // todo!("poll a future based on a field of ourselves - self-ref once again");
+                this.read_line = Some(this.parent.take().unwrap().read_line().boxed());
+                let line = match ready!(this.read_line.as_mut().expect("set above").poll(_cx)) {
+                    Some(line) => line?.map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,
+                    None => break (0, 0),
+                };
+                match this.handle_progress.as_mut() {
+                    Some(handle_progress) => {
+                        let band = line
+                            .decode_band()
+                            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+                        const ENCODED_BAND: usize = 1;
+                        match band {
+                            Band::Data(d) => break (U16_HEX_BYTES + ENCODED_BAND, d.len()),
+                            Band::Progress(d) => {
+                                let text = Text::from(d).0;
+                                handle_progress(false, text);
+                            }
+                            Band::Error(d) => {
+                                let text = Text::from(d).0;
+                                handle_progress(true, text);
+                            }
+                        };
+                    }
+                    None => {
+                        break match line.as_slice() {
+                            Some(d) => (U16_HEX_BYTES, d.len()),
+                            None => {
+                                return Poll::Ready(Err(io::Error::new(
+                                    io::ErrorKind::UnexpectedEof,
+                                    "encountered non-data line in a data-line only context",
+                                )))
                             }
                         }
                     }
-                };
-                this.pos = 0;
-            }
+                }
+            };
+            this.cap = cap + ofs;
+            this.pos = ofs;
         }
-        let cap = self.cap;
-        Poll::Ready(Ok(&self.get_mut().buf[..cap]))
+        Poll::Ready(Ok(&this.parent.as_ref().unwrap().buf[this.pos..this.cap]))
     }
 
     fn consume(self: Pin<&mut Self>, amt: usize) {