I want to read a line from a TCPStream, write another line to it, and then repeat. The issue is that BufReader::new takes ownership of my TCPStream variable:
let stream = ...; // TCPStream let reader = BufReader::new(stream); // moved its value // can't use stream here anymore What is a simple solution to this?
let mut stream = ...; let reader = BufReader::new(&stream); let writer = BufWriter::new(&stream); If we take a closer look at BufReader::new, we see that it takes an argument inner of type R, where R is just any type that implements Read:
impl<R: Read> BufReader<R> { pub fn new(inner: R) -> BufReader<R> { ... } } We then take a look at Read and see this implementation:
impl<'a> Read for &'a TcpStream So we can just pass a reference to the new function, like so:
let reader = BufReader::new(&stream); We will do the same for BufWriter and Write and will see that indeed there is this implementation:
impl<'a> Write for &'a TcpStream So we can, again, use an immutable reference to create the BufWriter.
You have several possibilities:
BufReaderBufReader using get_mutBufReader entirely and recover the stream using into_innerI would personally advise not using a BufReader unless you really need to bufferize the input; for a single line it does not seem worth it.
Otherwise, if you are done with the buffering, you can recover the underlying stream and if you are not you can temporarily buffer it.
Caution: Do be aware that the BufReader bufferizes reads, so when you borrow/recover the inner stream you short-circuit the buffered data; for reading it's an issue, in your case (writing) it should be fine.
