streamparser — 逐增量解析流输入

此 crate 提供适配器，将输入流转换为解析项序列，使用简单的增量解析函数。它支持同步和异步输入，并允许返回包含输入引用的项。

使用方法

将 crate 添加到您的 Cargo.toml

[dependencies]
streamparser = "0.1"

示例

一个完整示例：从流中解析空格分隔的单词

use std::{convert::Infallible, error::Error, io::Cursor};
use streamparser::{read::ReadSource, utf8::Utf8Adapter, Parse, Parsed, StreamParser, Streaming};

struct SplitWords;

impl<'a> Parse<'a> for SplitWords {
    type Input = &'a str;
    type Output = &'a str;
    type Error = Infallible;

    fn parse(
        &mut self,
        input: Self::Input,
    ) -> Result<Streaming<Parsed<Self::Output>>, Self::Error> {
        let trimmed = input.trim_start();
        let trimmed_count = input.len() - trimmed.len();
        match trimmed.find(' ') {
            Some(end) => Ok(Streaming::Item((
                Some(&trimmed[..end]),
                trimmed_count + end,
            ))),
            None => Ok(Streaming::Incomplete),
        }
    }

    fn parse_eof(
        &mut self,
        input: Self::Input,
    ) -> Result<Parsed<Self::Output>, Self::Error> {
        let trimmed = input.trim();
        if !trimmed.is_empty() {
            Ok((Some(trimmed), input.len()))
        } else {
            Ok((None, input.len()))
        }
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut results = Vec::new();
    let mut parser = StreamParser::new(
        Utf8Adapter::new(SplitWords),
        ReadSource::new(Cursor::new(b"words separated by whitespace"), 6),
    );
    while let Some(streaming) = parser.get()? {
        match streaming {
            Streaming::Item(item) => {
                results.push(item.to_owned());
            }
            Streaming::Incomplete => parser.advance()?,
        }
    }
    assert_eq!(results, vec!["words", "separated", "by", "whitespace",]);
    Ok(())
}

文档

参考文档

开发

版本

• 在 Cargo.toml 中提升版本
• 对于主要版本：在 README.md 中提升版本
• 将提交标记为 v<VERSION>，例如 v0.1.0