Struct NTriplesParser

Source

pub struct NTriplesParser { /* private fields */ }

Expand description

A N-Triples streaming parser.

Count the number of people:

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

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

Implementations§

Source §

impl NTriplesParser

Source

pub fn new() -> Self

Builds a new NTriplesParser.

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 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 = r#"<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_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), ) -> 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 = r#"<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);

Source

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

Creates a vector of parsers 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 = r#"<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, 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 split_file_for_parallel_parsing( self, path: impl AsRef<Path>, target_parallelism: usize, ) -> Result<Vec<ReaderNTriplesParser<Take<File>>>>

Creates a vector of parsers that may be used to parse an NTriples file 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 schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let readers = NTriplesParser::new().split_file_for_parallel_parsing(&path, 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) -> LowLevelNTriplesParser

Allows parsing an 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);