borrow.rs

impl<T: Transport> BufferedTransport<T> {

    fn get_bytes(&mut self) -> io::Result<&[u8]> {
        if self.rpos == self.rbuf.len() {
            self.rpos = 0;
            self.rcap = try!(self.underlying.read(&mut self.rbuf));
        }

        Ok(&self.rbuf[self.rpos..self.rcap])
    }

    fn consume(&mut self, consumed: usize) {
        self.rpos += cmp::min(self.rcap, self.rpos + consumed);
    }
}

impl<T: TTransport> io::Read for TBufferedTransport<T> {
    fn read(&mut self, b: &mut [u8]) -> io::Result<usize> {
        let mut bytes_read = 0;

        loop {
            let copyable;
            {
                let buf = try!(self.get_bytes());

                let remaining = b.len() - bytes_read;

                copyable = cmp::min(remaining, buf.len());
                b[bytes_read..].copy_from_slice(&buf[0..copyable]);
            }
            bytes_read += copyable;
            self.consume(copyable);

            if bytes_read == b.len() || copyable == 0 {
                break
            }
        }

        Ok(bytes_read)
    }
}