Struct NTriplesParser

pub struct NTriplesParser<R: BufRead> { /* private fields */ }

A N-Triples and N-Triples-star streaming parser.

It implements the TriplesParser 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, or if a line uses deeply nested triples.

Count the number of people using the TriplesParser API:

use rio_turtle::{NTriplesParser, TurtleError};
use rio_api::parser::TriplesParser;
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/foo> <http://schema.org/name> \"Foo\" .
<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;
NTriplesParser::new(file.as_ref()).parse_all(&mut |t| {
    if t.predicate == rdf_type && t.object == schema_person.into() {
        count += 1;
    }
    Ok(()) as Result<(), TurtleError>
})?;
assert_eq!(2, count);

Implementations

impl<R: BufRead> NTriplesParser<R>

pub fn new(reader: R) -> Self

Trait Implementations

impl<R: BufRead> TriplesParser for NTriplesParser<R>

type Error = TurtleError

fn parse_step<E: From<TurtleError>>( &mut self, on_triple: &mut impl FnMut(Triple<'_>) -> Result<(), E>, ) -> Result<(), E>

Parses a small chunk of the file and calls on_triple each time a new triple is read. (A “small chunk” could be a line for an N-Triples parser.)

fn is_end(&self) -> bool

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

fn parse_all<E>( &mut self, on_triple: &mut impl FnMut(Triple<'_>) -> Result<(), E>, ) -> Result<(), E>

where E: From<Self::Error>,

Parses the complete file and calls on_triple each time a new triple is read.

fn into_iter<T, E, F>( self, convert_triple: F, ) -> TriplesParserIterator<T, E, F, Self>

where E: From<Self::Error>, F: FnMut(Triple<'_>) -> Result<T, E>,

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