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 buf = try!(self.get_bytes());

            let mut copyable = 0;
            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)
    }
}

error[E0499]: cannot borrow `*self` as mutable more than once at a time
   --> src/transport/buffered.rs:96:13
    |
87  |             let buf = try!(self.get_bytes());
    |                            ---- first mutable borrow occurs here
...
96  |             self.consume(copyable);
    |             ^^^^ second mutable borrow occurs here
...
101 |         }
    |         - first borrow ends here

error: aborting due to previous error