Struct TriGParser

pub struct TriGParser { /* private fields */ }

A TriG streaming parser.

Support for TriG-star is available behind the rdf-star feature and the TriGParser::with_quoted_triples option.

Count the number of people:

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

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 quad in TriGParser::new().for_reader(file.as_ref()) {
    let quad = quad?;
    if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Implementations

impl TriGParser

pub fn new() -> Self

Builds a new TriGParser.

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 TriG-star.

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

Parses a TriG file from a Read implementation.

Count the number of people:

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

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 quad in TriGParser::new().for_reader(file.as_ref()) {
    let quad = quad?;
    if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

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

Parses a TriG file from a byte slice.

Count the number of people:

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

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 quad in TriGParser::new().for_slice(file) {
    let quad = quad?;
    if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

pub fn low_level(self) -> LowLevelTriGParser

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

Count the number of people:

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

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 = TriGParser::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 quads from the parser as possible
    while let Some(quad) = parser.parse_next() {
        let quad = quad?;
        if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
            count += 1;
        }
    }
}
assert_eq!(2, count);

Trait Implementations

impl Clone for TriGParser

fn clone(&self) -> TriGParser

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for TriGParser

fn default() -> TriGParser

Returns the “default value” for a type.