Struct Parser

Source

pub struct Parser { /* private fields */ }

Expand description

The configurable parser.

§Examples

use parse_net::{sfv::Parser, ErrorKind, Limits};

let strict = Parser::new(Limits::DEFAULT.max_list_members(2));
assert_eq!(strict.list(b"a, b, c").unwrap_err().kind(), ErrorKind::TooManyMembers);
assert_eq!(Parser::default().list(b"a, b, c")?.len(), 3);

Implementations§

Source §

impl Parser

Source

pub const fn new(limits: Limits) -> Self

A parser with limits.

§Examples

use parse_net::{sfv::Parser, Limits};

let p = Parser::new(Limits::DEFAULT.max_dictionary_members(1));
assert!(p.dictionary(b"a").is_ok());
assert!(p.dictionary(b"a, b").is_err());

Source

pub fn item<'a>(&self, v: &'a [u8]) -> Result<Item<'a>, ParseError>

Parses an Item (section 4.2.3).

§Errors

See parse_item.

§Examples

use parse_net::sfv::{BareItem, Parser};

let item = Parser::default().item(b"?0;x")?;
assert_eq!(item.bare, BareItem::Boolean(false));
assert_eq!(item.params.len(), 1);

Source

pub fn list<'a>(&self, v: &'a [u8]) -> Result<List<'a>, ParseError>

Parses a List (section 4.2.1).

§Errors

See parse_list.

§Examples

use parse_net::sfv::Parser;

assert_eq!(Parser::default().list(b"a, (b c);q=1")?.len(), 2);
assert!(Parser::default().list(b"a,,b").is_err());

Source

pub fn dictionary<'a>(&self, v: &'a [u8]) -> Result<Dictionary<'a>, ParseError>

Parses a Dictionary (section 4.2.2).

§Errors

See parse_dictionary.

§Examples

use parse_net::sfv::{BareItem, Member, Parser};

let d = Parser::default().dictionary(b"a=1, b")?;
assert!(matches!(d.get("a"), Some(Member::Item(i)) if i.bare == BareItem::Integer(1)));

Source

pub fn list_lines<'a>( &self, lines: &'a [&'a [u8]], ) -> Result<ListLines<'a>, ParseError>

Parses several field lines as one List: each line must parse on its own, an empty line fails the field, and the member limit counts across lines.

§Errors

As list, with ParseError::line set; an empty line is ErrorKind::Empty.

§Examples

use parse_net::{sfv::Parser, ErrorKind};

let good: [&[u8]; 2] = [b"a", b"b, c"];
assert_eq!(Parser::default().list_lines(&good)?.len(), 3);
let bad: [&[u8]; 2] = [b"a", b""];
let e = Parser::default().list_lines(&bad).unwrap_err();
assert_eq!((e.kind(), e.line()), (ErrorKind::Empty, 1));

Source

pub fn dictionary_lines<'a>( &self, lines: &'a [&'a [u8]], ) -> Result<DictionaryLines<'a>, ParseError>

Parses several field lines as one Dictionary (the last value of a repeated key wins across lines).

§Errors

As list_lines.

§Examples

use parse_net::sfv::{BareItem, Member, Parser};

let lines: [&[u8]; 2] = [b"a=1", b"a=2"];
let d = Parser::default().dictionary_lines(&lines)?;
assert!(matches!(d.get("a"), Some(Member::Item(i)) if i.bare == BareItem::Integer(2)));

Source

pub fn visit_item<'a, V: Visitor<'a>>( &self, v: &'a [u8], visitor: &mut V, ) -> Result<(), ParseError>

Parses an Item, reporting it to visitor.

§Errors

As item, or the visitor’s error.

§Examples

use parse_net::{sfv::{BareItem, Parser, Visitor}, Limits, ParseError};

struct Count(usize);
impl<'a> Visitor<'a> for Count {
    fn item(&mut self, _: BareItem<'a>) -> Result<(), ParseError> { Ok(()) }
    fn param(&mut self, _: &'a str, _: BareItem<'a>) -> Result<(), ParseError> { self.0 += 1; Ok(()) }
}

let mut c = Count(0);
Parser::new(Limits::DEFAULT).visit_item(b"a;x=1;y", &mut c)?;
assert_eq!(c.0, 2);

Source

pub fn visit_list<'a, V: Visitor<'a>>( &self, v: &'a [u8], visitor: &mut V, ) -> Result<(), ParseError>

Parses a List, reporting it to visitor.

§Errors

As list, or the visitor’s error.

§Examples

use parse_net::{sfv::{BareItem, Parser, Visitor}, Limits, ParseError};

struct Count(usize);
impl<'a> Visitor<'a> for Count {
    fn item(&mut self, _: BareItem<'a>) -> Result<(), ParseError> { self.0 += 1; Ok(()) }
    fn param(&mut self, _: &'a str, _: BareItem<'a>) -> Result<(), ParseError> { Ok(()) }
}

let mut c = Count(0);
Parser::new(Limits::DEFAULT).visit_list(b"a, (b c);q", &mut c)?;
assert_eq!(c.0, 3);

Source

pub fn visit_dictionary<'a, V: Visitor<'a>>( &self, v: &'a [u8], visitor: &mut V, ) -> Result<(), ParseError>

Parses a Dictionary, reporting it to visitor.

§Errors

As dictionary, or the visitor’s error.

§Examples

use parse_net::{sfv::{BareItem, Parser, Visitor}, Limits, ParseError};

struct Count(usize);
impl<'a> Visitor<'a> for Count {
    fn item(&mut self, _: BareItem<'a>) -> Result<(), ParseError> { Ok(()) }
    fn param(&mut self, _: &'a str, _: BareItem<'a>) -> Result<(), ParseError> { Ok(()) }
    fn key(&mut self, _: &'a str) -> Result<(), ParseError> { self.0 += 1; Ok(()) }
}

let mut c = Count(0);
Parser::new(Limits::DEFAULT).visit_dictionary(b"a=1, b, c=(x y)", &mut c)?;
assert_eq!(c.0, 3);