Method parse

src/protocol/parser.rs:51–84

(&mut self, input: BufferParameter, mut callback: F)

    }

    pub fn parse<F>(&mut self, input: BufferParameter, mut callback: F) -> Result<()>
    where
        F: FnMut(BackendMessage) -> Result<()>,
    {
        self.buffer.extend_from_slice(input);

        let mut cursor = 0usize;
        while self.buffer.len().saturating_sub(cursor) >= HEADER_LEN {
            let code = self.buffer[cursor];
            let length_bytes = &self.buffer[cursor + 1..cursor + HEADER_LEN];
            let length = u32::from_be_bytes([
                length_bytes[0],
                length_bytes[1],
                length_bytes[2],
                length_bytes[3],
            ]) as usize;
            let total_len = 1 + length;

            if self.buffer.len() - cursor < total_len {
                break; // wait for more data
            }

            let body = &self.buffer[cursor + HEADER_LEN..cursor + total_len]; // exclude code+length header
            let message = self.handle_packet(code, body, length)?;
            callback(message)?;
            cursor += total_len;
        }

        if cursor > 0 {
            self.buffer.drain(0..cursor);
        }

        Ok(())
    }

    fn handle_packet(&self, code: u8, bytes: &[u8], length: usize) -> Result<BackendMessage> {
        let mut reader = BufferReader::default();