Method read

battlecode-engine/src/controller/streams.rs:29–69

(&mut self)

    }

    pub(crate) fn read<T: DeserializeOwned>(&mut self) -> Result<T, Error> {
        let newline = self.buf.iter().position(|&b| b == b'\n');
        if let Some(idx) = newline {
            let t = from_slice(&self.buf[..idx]);
            self.buf.drain(..idx+1);
            return Ok(t?);
        }

        let mut buf: [u8; 256] = unsafe { mem::uninitialized() };

        loop {
            let len = self.stream.read(&mut buf[..]);
            match len {
                Ok(len) => {
                    if len == 0 {
                        thread::sleep(Duration::new(0, 1_000_000));
                        continue;
                    }

                    let newline = buf[..len].iter().position(|&b| b == b'\n');
                    if let Some(idx) = newline {
                        self.buf.extend(buf[..idx].iter());
                        let t = from_slice(&self.buf[..]);
                        self.buf.clear();
                        self.buf.extend(buf[idx+1..len].iter());
                        return Ok(t?);
                    } else {
                        // no data; continue
                        self.buf.extend(buf[..len].iter())
                    }
                },
                Err(e) => {
                    if e.kind() == ErrorKind::Interrupted {
                        continue;
                    } else {
                        Err(e)?
                    }
                }
            }
        }
    }

    pub(crate) fn write<T: Serialize>(&mut self, value: &T) -> Result<(), Error> {
        to_writer(&mut self.stream, value)?;