Struct TurtleParser

pub struct TurtleParser { /* private fields */ }

A Turtle streaming parser.

Support for Turtle-star is available behind the rdf-star feature and the TurtleParser::with_quoted_triples option.

Count the number of people:

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

let file = br#"@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_ref()) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Implementations

impl TurtleParser

pub fn new() -> Self

Builds a new TurtleParser.

pub fn unchecked(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, broken RDF might be emitted by the parser.

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

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

pub fn with_quoted_triples(self) -> Self

Enables Turtle-star.

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::vocab::rdf;
use oxrdf::NamedNodeRef;
use oxttl::TurtleParser;

let file = br#"@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_ref()) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

pub fn for_slice(self, slice: &[u8]) -> SliceTurtleParser<'_>

Parses Turtle file from a byte slice.

Count the number of people:

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

let file = br#"@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);

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

Creates a vector of iterators 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::vocab::rdf;
use oxrdf::NamedNodeRef;
use oxttl::TurtleParser;
use rayon::iter::{IntoParallelIterator, ParallelIterator};

let file = br#"@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.as_ref(), 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);

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::vocab::rdf;
use oxrdf::NamedNodeRef;
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);

Trait Implementations

impl Clone for TurtleParser

fn clone(&self) -> TurtleParser

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for TurtleParser

fn default() -> TurtleParser

Returns the “default value” for a type.