Struct TurtleParser

Source

pub struct TurtleParser { /* private fields */ }

Expand description

A Turtle streaming parser.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxttl::TurtleParser;

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in TurtleParser::new().for_reader(file.as_bytes()) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Implementations§

Source §

impl TurtleParser

Source

pub fn new() -> Self

Builds a new TurtleParser.

Source

pub fn lenient(self) -> Self

Assumes the file is valid to make parsing faster.

It will skip some validations.

Note that if the file is actually not valid, the parser might emit broken RDF.

Source

pub fn unchecked(self) -> Self

👎Deprecated since 0.2.0:

Use lenient() instead

Source

pub fn with_base_iri( self, base_iri: impl Into<String>, ) -> Result<Self, IriParseError>

Source

pub fn with_prefix( self, prefix_name: impl Into<String>, prefix_iri: impl Into<String>, ) -> Result<Self, IriParseError>

Source

pub fn for_reader<R: Read>(self, reader: R) -> ReaderTurtleParser<R> ⓘ

Parses a Turtle file from a Read implementation.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxttl::TurtleParser;

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in TurtleParser::new().for_reader(file.as_bytes()) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Source

pub fn for_slice( self, slice: &(impl AsRef<[u8]> + ?Sized), ) -> SliceTurtleParser<'_> ⓘ

Parses Turtle file from a byte slice.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxttl::TurtleParser;

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in TurtleParser::new().for_slice(file) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Source

pub fn split_slice_for_parallel_parsing( self, slice: &(impl AsRef<[u8]> + ?Sized), target_parallelism: usize, ) -> Vec<SliceTurtleParser<'_>>

Creates a vector of parsers that may be used to parse a Turtle document slice in parallel. To dynamically specify target_parallelism, use e.g. std::thread::available_parallelism. Intended to work on large documents. Can fail or return wrong results if there are prefixes or base iris that are not defined at the top of the document, or valid turtle syntax inside literal values.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxttl::TurtleParser;
use rayon::iter::{IntoParallelIterator, ParallelIterator};

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let readers = TurtleParser::new().split_slice_for_parallel_parsing(file, 2);
let count = readers
    .into_par_iter()
    .map(|reader| {
        let mut count = 0;
        for triple in reader {
            let triple = triple.unwrap();
            if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
                count += 1;
            }
        }
        count
    })
    .sum();
assert_eq!(2, count);

Source

pub fn low_level(self) -> LowLevelTurtleParser

Allows to parse a Turtle file by using a low-level API.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxttl::TurtleParser;

let file: [&[u8]; 5] = [
    b"@base <http://example.com/>",
    b". @prefix schema: <http://schema.org/> .",
    b"<foo> a schema:Person",
    b" ; schema:name \"Foo\" . <bar>",
    b" a schema:Person ; schema:name \"Bar\" .",
];

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
let mut parser = TurtleParser::new().low_level();
let mut file_chunks = file.iter();
while !parser.is_end() {
    // We feed more data to the parser
    if let Some(chunk) = file_chunks.next() {
        parser.extend_from_slice(chunk);
    } else {
        parser.end(); // It's finished
    }
    // We read as many triples from the parser as possible
    while let Some(triple) = parser.parse_next() {
        let triple = triple?;
        if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
            count += 1;
        }
    }
}
assert_eq!(2, count);