Struct rio_turtle::NQuadsParser

pub struct NQuadsParser<R: BufRead> { /* fields omitted */ }

A N-Quads streaming parser.

It implements the QuadParser trait.

Its memory consumption is linear in the size of the longest line of the file. It does not do any allocation during parsing except buffer resizing if a line significantly longer than the previous is encountered.

Count the number of of people using the QuadParser API:

use rio_turtle::NQuadsParser;
use rio_api::parser::QuadParser;
use rio_api::model::NamedNode;

let file = b"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> <http://example.com/> .
<http://example.com/foo> <http://schema.org/name> \"Foo\" <http://example.com/> .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> \"Bar\" .";

let rdf_type = NamedNode { iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" };
let schema_person = NamedNode { iri: "http://schema.org/Person" };
let mut count = 0;
NQuadsParser::new(file.as_ref()).unwrap().parse_all(&mut |t| {
    if t.predicate == rdf_type && t.object == schema_person.into() {
        count += 1;
    }
}).unwrap();
assert_eq!(2, count)

Methods

impl<R: BufRead> NQuadsParser<R>

pub fn new(reader: R) -> Result<Self, TurtleError>

Trait Implementations

impl<R: BufRead> QuadParser for NQuadsParser<R>

type Error = TurtleError

fn parse_step(
    &mut self,
    on_quad: &mut impl FnMut(Quad)
) -> Result<(), TurtleError>

Parses a small chunk of the file and calls on_quad each time a new triple is read.

fn is_end(&self) -> bool

Returns true if the file has been completely consumed by the parser.

fn parse_all<impl FnMut(Quad) -> ()>(
    &mut self,
    on_quad: &mut impl FnMut(Quad) -> ()
) -> Result<(), Self::Error> where
    impl FnMut(Quad) -> (): FnMut(Quad), 

Parses the complete file and calls on_quad each time a new quad is read.

fn into_iter<T, E, F>(
    self,
    convert_quad: F
) -> QuadsParserIterator<T, E, F, Self> where
    E: From<Self::Error>,
    F: FnMut(Quad) -> Result<T, E>, 

Converts the parser into a Result<T, E> iterator.