Struct NTriplesParser

pub struct NTriplesParser { /* private fields */ }

A N-Triples streaming parser.

Support for N-Triples-star is available behind the rdf-star feature and the NTriplesParser::with_quoted_triples option.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NTriplesParser;

let file = br#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in NTriplesParser::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 NTriplesParser

pub fn new() -> Self

Builds a new NTriplesParser.

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_quoted_triples(self) -> Self

Enables N-Triples-star.

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

Parses a N-Triples file from a Read implementation.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NTriplesParser;

let file = br#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in NTriplesParser::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]) -> SliceNTriplesParser<'_>

Parses a N-Triples file from a byte slice.

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NTriplesParser;

let file = br#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in NTriplesParser::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<'a>( &self, slice: &'a [u8], target_parallelism: usize, ) -> Vec<SliceNTriplesParser<'a>>

Creates a vector of iterators that may be used to parse an NTriples document slice in parallel. To dynamically specify target_parallelism, use e.g. std::thread::available_parallelism. Intended to work on large documents.

Count the number of people:

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

let file = br#"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/foo> <http://schema.org/name> "Foo" .
<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .
<http://example.com/bar> <http://schema.org/name> "Bar" ."#;

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let readers = NTriplesParser::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) -> LowLevelNTriplesParser

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

Count the number of people:

use oxrdf::{NamedNodeRef, vocab::rdf};
use oxttl::NTriplesParser;

let file: [&[u8]; 4] = [
    b"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .\n",
    b"<http://example.com/foo> <http://schema.org/name> \"Foo\" .\n",
    b"<http://example.com/bar> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> .\n",
    b"<http://example.com/bar> <http://schema.org/name> \"Bar\" .\n"
];

let schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
let mut parser = NTriplesParser::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 NTriplesParser

fn clone(&self) -> NTriplesParser

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for NTriplesParser

fn default() -> NTriplesParser

Returns the “default value” for a type.