Struct rio_turtle::TurtleParser

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

A Turtle and Turtle-star streaming parser.

It implements the TriplesParser trait.

Count the number of people using the TriplesParser API:

use rio_turtle::{TurtleParser, TurtleError};
use rio_api::parser::TriplesParser;
use rio_api::model::NamedNode;

let file = b"@prefix schema: <http://schema.org/> .
<http://example.com/foo> a schema:Person ;
    schema:name  \"Foo\" .
<http://example.com/bar> a schema:Person ;
    schema: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;
TurtleParser::new(file.as_ref(), None).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> TurtleParser<R>

pub fn new(reader: R, base_iri: Option<Iri<String>>) -> Self

Builds the parser from a BufRead implementation, and a base IRI for relative IRI resolution.

pub fn prefixes(&self) -> &HashMap<String, String>

The list of IRI prefixes considered at the current step of the parsing.

This method returns the mapping from prefix name to prefix value. It is empty at the beginning of the parsing and gets updated when prefixes are encountered. It should be full at the end of the parsing (but if a prefix is overridden, only the latest version will be returned).

use std::collections::HashMap;
use rio_api::model::NamedNode;
use rio_api::parser::TriplesParser;
use rio_turtle::{TurtleError, TurtleParser};

let file = b"@prefix schema: <http://schema.org/> .
@prefix ex: <http://example.com/> .
ex: a schema:WebSite .
@prefix ex: <http://example.org/> .
ex: a schema:WebSite .";

let mut parser = TurtleParser::new(file.as_ref(), None);
assert_eq!(parser.prefixes(), &HashMap::new()); // No prefix at the beginning

let _: Result<_, TurtleError> = parser.parse_step(&mut |_| panic!("We read the first prefix"));
assert_eq!(parser.prefixes().len(), 1);
assert_eq!(parser.prefixes()["schema"], "http://schema.org/");

let _: Result<_, TurtleError> = parser.parse_step(&mut |_| panic!("We read the second prefix"));
assert_eq!(parser.prefixes().len(), 2);
assert_eq!(parser.prefixes()["schema"], "http://schema.org/");
assert_eq!(parser.prefixes()["ex"], "http://example.com/");

let _: Result<_, TurtleError> = parser.parse_step(&mut |t| {
    assert_eq!(t.subject, NamedNode { iri: "http://example.com/" }.into()); // We read the first triple
    Ok(())
});

let _: Result<_, TurtleError> = parser.parse_step(&mut |_| panic!("We read the new version of the ex: prefix"));
assert_eq!(parser.prefixes().len(), 2);
assert_eq!(parser.prefixes()["schema"], "http://schema.org/");
assert_eq!(parser.prefixes()["ex"], "http://example.org/");  

let _: Result<_, TurtleError> = parser.parse_step(&mut |t| {
    assert_eq!(t.subject, NamedNode { iri: "http://example.org/" }.into()); // We read the second triple
   Ok(())
});

Trait Implementations

impl<R: BufRead> TriplesParser for TurtleParser<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.