Struct stream_httparse::streaming_parser::RespParser

pub struct RespParser { /* fields omitted */ }

A single Instance of the ResponseParser that is used to parse HTTP-Responses

Implementations

impl RespParser

pub fn new_capacity(head_cap: usize) -> Self

Creates a new Instance of the Response-Parser with the given head_cap as its initial capacity for the HTTP-Head (First-Line + Headers)

pub fn clear(&mut self)

Clears the internal buffers and resets everything to the start and makes it ready to receive and parse another Response

This enables the reuse of a single parser, which helps to avoid extra allocations that are not needed.

pub fn block_parse(&mut self, bytes: &[u8]) -> (bool, usize)

Parses the given byte-chunk

Returns:

• True if the parser is done and finish can be called
• False if it is not yet done with parsing
• Some when there was still data in the given buffer, which was not consumed/used

pub fn finish<'a, 'b>(&'a mut self) -> Result<Response<'b>, ParseError> where
    'a: 'b, 

Finalizes the Response that is currently being Parsed by the Parser and returns a Response-Instance with the parsed Data

pub fn finish_owned<'a, 'owned>(
    &'a mut self
) -> Result<Response<'owned>, ParseError>

Finalizes the Response that is currently being Parsed by the Parser and returns an owned Response-Instance with the parsed Data. This means that the Response is independant of the Parser, unlike the normal finish Function. This freedom comes at the cost of more memory allocations and therefore less performance, so only use this where needed.