Method decode

src/lsp.rs:509–554

(&mut self, src: &mut BytesMut)

    type Error = CodecError;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        if self.remaining_bytes > src.len() {
            return Ok(None);
        }

        match parse_message(src) {
            Ok((remaining, message)) => {
                let message = str::from_utf8(message)?.to_string();
                let len = src.len() - remaining.len();
                src.advance(len);
                self.remaining_bytes = 0;
                // Ignore empty frame
                if message.is_empty() {
                    Ok(None)
                } else {
                    Ok(Some(message))
                }
            }

            Err(nom::Err::Incomplete(nom::Needed::Size(needed))) => {
                self.remaining_bytes = needed.get();
                Ok(None)
            }

            Err(nom::Err::Incomplete(nom::Needed::Unknown)) => Ok(None),

            Err(nom::Err::Error(err)) | Err(nom::Err::Failure(err)) => {
                let code = err.code;
                let parsed_bytes = src.len() - err.input.len();
                src.advance(parsed_bytes);
                match find_next_message(src) {
                    Ok((_, position)) => src.advance(position),
                    Err(_) => src.advance(src.len()),
                }
                match code {
                    nom::error::ErrorKind::Digit | nom::error::ErrorKind::MapRes => {
                        Err(CodecError::InvalidLength)
                    }
                    nom::error::ErrorKind::Char | nom::error::ErrorKind::IsNot => {
                        Err(CodecError::InvalidType)
                    }
                    _ => Err(CodecError::MissingHeader),
                }
            }
        }
    }
}

#[inline]