Struct rio_turtle::TurtleParser
source · pub struct TurtleParser<R: BufRead> { /* private fields */ }
Expand description
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§
source§impl<R: BufRead> TurtleParser<R>
impl<R: BufRead> TurtleParser<R>
sourcepub fn new(reader: R, base_iri: Option<Iri<String>>) -> Self
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.
sourcepub fn prefixes(&self) -> &HashMap<String, String>
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§
source§impl<R: BufRead> TriplesParser for TurtleParser<R>
impl<R: BufRead> TriplesParser for TurtleParser<R>
type Error = TurtleError
source§fn parse_step<E: From<TurtleError>>(
&mut self,
on_triple: &mut impl FnMut(Triple<'_>) -> Result<(), E>,
) -> Result<(), E>
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.) Read moreAuto Trait Implementations§
impl<R> Freeze for TurtleParser<R>where
R: Freeze,
impl<R> RefUnwindSafe for TurtleParser<R>where
R: RefUnwindSafe,
impl<R> Send for TurtleParser<R>where
R: Send,
impl<R> Sync for TurtleParser<R>where
R: Sync,
impl<R> Unpin for TurtleParser<R>where
R: Unpin,
impl<R> UnwindSafe for TurtleParser<R>where
R: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more