Struct NQuadsParser

pub struct NQuadsParser { /* private fields */ }

A N-Quads streaming parser.

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

Count the number of people:

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

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 quad in NQuadsParser::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 NQuadsParser

pub fn new() -> Self

Builds a new NQuadsParser.

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

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

Parses a N-Quads file from a Read implementation.

Count the number of people:

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

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 quad in NQuadsParser::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]) -> SliceNQuadsParser<'_>

Parses a N-Quads file from a byte slice.

Count the number of people:

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

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 quad in NQuadsParser::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 split_slice_for_parallel_parsing<'a>( &self, slice: &'a [u8], target_parallelism: usize, ) -> Vec<SliceNQuadsParser<'a>>

Creates a vector of iterators that may be used to parse an NQuads 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::NQuadsParser;
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 = NQuadsParser::new().split_slice_for_parallel_parsing(file.as_ref(), 2);
let count = readers
    .into_par_iter()
    .map(|reader| {
        let mut count = 0;
        for quad in reader {
            let quad = quad.unwrap();
            if quad.predicate == rdf::TYPE && quad.object == schema_person.into() {
                count += 1;
            }
        }
        count
    })
    .sum();
assert_eq!(2, count);

pub fn low_level(self) -> LowLevelNQuadsParser

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

Count the number of people:

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

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 = NQuadsParser::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 NQuadsParser

fn clone(&self) -> NQuadsParser

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for NQuadsParser

fn default() -> NQuadsParser

Returns the “default value” for a type.