use crate::{    borrowed::{Band, Text},    decode, MAX_DATA_LEN, MAX_LINE_LEN,};use crate::{PacketLine, RemoteProgress};use bstr::ByteSlice;use git_features::{progress, progress::Progress};use std::io; /// Read pack lines one after another, without consuming more than needed from the underlying/// `Read`. `Flush` lines cause the reader to stop producing lines forever, leaving `Read` at the/// start of whatever comes next.pub struct Reader<T> {    pub inner: T,    buf: Vec<u8>,    delimiter: PacketLine<'static>,    is_done: bool,} impl<T> Reader<T>where    T: io::Read,{    pub fn new(inner: T, delimiter: impl Into<Option<PacketLine<'static>>>) -> Self {        Reader {            inner,            buf: vec![0; MAX_LINE_LEN],            delimiter: delimiter.into().unwrap_or(PacketLine::Flush),            is_done: false,        }    }     pub fn reset(&mut self) {        debug_assert!(self.is_done, "reset is only effective if we are actually done");        self.is_done = false;    }     fn read_line_inner<'a>(reader: &mut T, buf: &'a mut Vec<u8>) -> io::Result<Result<PacketLine<'a>, decode::Error>> {        let (hex_bytes, data_bytes) = buf.split_at_mut(4);        reader.read_exact(hex_bytes)?;        let num_data_bytes = match decode::hex_prefix(hex_bytes) {            Ok(decode::PacketLineOrWantedSize::Line(line)) => return Ok(Ok(line)),            Ok(decode::PacketLineOrWantedSize::Wanted(additional_bytes)) => additional_bytes as usize,            Err(err) => return Ok(Err(err)),        };         let (data_bytes, _) = data_bytes.split_at_mut(num_data_bytes);        reader.read_exact(data_bytes)?;        match decode::to_data_line(data_bytes) {            Ok(line) => Ok(Ok(line)),            Err(err) => Ok(Err(err)),        }    }     pub fn read_line(&mut self) -> Option<io::Result<Result<PacketLine, decode::Error>>> {        if self.is_done {            return None;        }        match Self::read_line_inner(&mut self.inner, &mut self.buf) {            Ok(Ok(line)) if line == self.delimiter => {                self.is_done = true;                None            }            res => Some(res),        }    }     pub fn as_read_with_sidebands<P: Progress>(        &mut self,        progress: P,        parse_progress: fn(&[u8]) -> Option<RemoteProgress>,    ) -> ReadWithProgress<T, P> {        ReadWithProgress::with_progress(self, progress, parse_progress)    }     pub fn as_read(&mut self) -> ReadWithProgress<T, progress::Discard> {        ReadWithProgress::new(self)    }} type ProgressAndParser<P> = (P, fn(&[u8]) -> Option<RemoteProgress>); pub struct ReadWithProgress<'a, T, P> {    parent: &'a mut Reader<T>,    progress_and_parse: Option<ProgressAndParser<P>>,    buf: Vec<u8>,    pos: usize,    cap: usize,} impl<'a, T> ReadWithProgress<'a, T, progress::Discard>where    T: io::Read,{    fn new(parent: &'a mut Reader<T>) -> Self {        ReadWithProgress {            parent,            progress_and_parse: None,            buf: vec![0; MAX_DATA_LEN],            pos: 0,            cap: 0,        }    }} impl<'a, T, P> ReadWithProgress<'a, T, P>where    T: io::Read,    P: Progress,{    fn with_progress(        parent: &'a mut Reader<T>,        progress: P,        parse_progress: fn(&[u8]) -> Option<RemoteProgress>,    ) -> Self {        ReadWithProgress {            parent,            progress_and_parse: Some((progress, parse_progress)),            buf: vec![0; MAX_DATA_LEN],            pos: 0,            cap: 0,        }    }} impl<'a, T, P> io::BufRead for ReadWithProgress<'a, T, P>where    T: io::Read,    P: Progress,{    fn fill_buf(&mut self) -> io::Result<&[u8]> {        use io::Read;        if self.pos >= self.cap {            debug_assert!(self.pos == self.cap);            self.cap = loop {                let line = match self.parent.read_line() {                    Some(line) => line?.map_err(|err| io::Error::new(io::ErrorKind::Other, err))?,                    None => break 0,                };                match self.progress_and_parse.as_mut() {                    Some((progress, parse_progress)) => {                        let mut band = line                            .decode_band()                            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;                        fn progress_name(current: Option<String>, action: &[u8]) -> String {                            match current {                                Some(current) => format!("{}: {}", current, action.as_bstr()),                                None => action.as_bstr().to_string(),                            }                        }                        match band {                            Band::Data(ref mut d) => break d.read(&mut self.buf)?,                            Band::Progress(d) => {                                let text = Text::from(d).0;                                match (parse_progress)(text) {                                    Some(RemoteProgress {                                        action,                                        percent: _,                                        step,                                        max,                                    }) => {                                        progress.set_name(progress_name(progress.name(), action));                                        progress.init(max, git_features::progress::count("objects"));                                        if let Some(step) = step {                                            progress.set(step);                                        }                                    }                                    None => progress.set_name(progress_name(progress.name(), text)),                                };                            }                            Band::Error(d) => progress.fail(progress_name(None, Text::from(d).0)),                        };                    }                    None => {                        break match line.as_slice() {                            Some(ref mut d) => d.read(&mut self.buf)?,                            None => {                                return Err(io::Error::new(                                    io::ErrorKind::UnexpectedEof,                                    "encountered non-data line in a data-line only context",                                ))                            }                        }                    }                }            };            self.pos = 0;        }        Ok(&self.buf[self.pos..self.cap])    }     fn consume(&mut self, amt: usize) {        self.pos = std::cmp::min(self.pos + amt, self.cap);    }} impl<'a, T, P> io::Read for ReadWithProgress<'a, T, P>where    T: io::Read,    P: Progress,{    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {        use std::io::BufRead;        let nread = {            let mut rem = self.fill_buf()?;            rem.read(buf)?        };        self.consume(nread);        Ok(nread)    }}