Struct BufParse 

pub struct BufParse<R> { /* private fields */ }

A streaming control file parser that buffers input internally.

This type handles incrementally reading and buffering input from a source implementing the BufParseInput trait.

Example

use debcontrol::{BufParse, Streaming};
use std::fs::File;

let f = File::open(file_name).unwrap();
let mut buf_parse = BufParse::new(f, 4096);
while let Some(result) = buf_parse.try_next().unwrap() {
    match result {
        Streaming::Item(paragraph) => {
            for field in paragraph.fields {
                println!("{}: {}", field.name, &field.value);
            }
        }
        Streaming::Incomplete => buf_parse.buffer().unwrap()
    }
}

Implementations

impl<R: BufParseInput> BufParse<R>

pub fn new(read: R, chunk_size: usize) -> Self

Create a new parser.

pub fn buffer(&mut self) -> Result<(), R::Error>

Read the next chunk of input into the buffer.

pub fn try_next( &mut self, ) -> Result<Option<Streaming<Paragraph<'_>>>, BufParseError<'_>>

Try to parse the next paragraph from the input.

A syntax error encountered during parsing is returned immediately. Otherwise, the nature of the Ok result determines what to do next:

• If it’s None, all input has been parsed. Future calls will continue to return None.
• If it’s Streaming::Incomplete, there’s not enough buffered input to make a parsing decision. Call buffer to read more input.
• If it’s Streaming::Item, a paragraph was parsed. Call try_next again after processing it.

pub fn into_inner(self) -> R

Consume this BufParse and return the wrapped input source.

Any input that was already buffered will be lost.

Trait Implementations

impl<R: Debug> Debug for BufParse<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.