Struct N3Parser 

pub struct N3Parser { /* private fields */ }

A N3 streaming parser.

Count the number of people:

use oxrdf::NamedNode;
use oxrdf::vocab::rdf;
use oxttl::n3::{N3Parser, N3Term};

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let rdf_type = N3Term::NamedNode(rdf::TYPE.into_owned());
let schema_person = N3Term::NamedNode(NamedNode::new("http://schema.org/Person")?);
let mut count = 0;
for triple in N3Parser::new().for_reader(file.as_bytes()) {
    let triple = triple?;
    if triple.predicate == rdf_type && triple.object == schema_person {
        count += 1;
    }
}
assert_eq!(2, count);

Implementations

impl N3Parser

pub fn new() -> Self

Builds a new N3Parser.

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.

pub fn unchecked(self) -> Self

👎Deprecated since 0.2.0:

Use lenient() instead

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 for_reader<R: Read>(self, reader: R) -> ReaderN3Parser<R>

Parses a N3 file from a Read implementation.

Count the number of people:

use oxrdf::NamedNode;
use oxttl::n3::{N3Parser, N3Term};

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let rdf_type = N3Term::NamedNode(NamedNode::new(
    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
)?);
let schema_person = N3Term::NamedNode(NamedNode::new("http://schema.org/Person")?);
let mut count = 0;
for triple in N3Parser::new().for_reader(file.as_bytes()) {
    let triple = triple?;
    if triple.predicate == rdf_type && triple.object == schema_person {
        count += 1;
    }
}
assert_eq!(2, count);

pub fn for_slice(self, slice: &(impl AsRef<[u8]> + ?Sized)) -> SliceN3Parser<'_>

Parses a N3 file from a byte slice.

Count the number of people:

use oxrdf::NamedNode;
use oxrdf::vocab::rdf;
use oxttl::n3::{N3Parser, N3Term};

let file = r#"@base <http://example.com/> .
@prefix schema: <http://schema.org/> .
<foo> a schema:Person ;
    schema:name "Foo" .
<bar> a schema:Person ;
    schema:name "Bar" ."#;

let rdf_type = N3Term::NamedNode(rdf::TYPE.into_owned());
let schema_person = N3Term::NamedNode(NamedNode::new("http://schema.org/Person")?);
let mut count = 0;
for triple in N3Parser::new().for_slice(file) {
    let triple = triple?;
    if triple.predicate == rdf_type && triple.object == schema_person {
        count += 1;
    }
}
assert_eq!(2, count);

pub fn low_level(self) -> LowLevelN3Parser

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

Count the number of people:

use oxrdf::NamedNode;
use oxrdf::vocab::rdf;
use oxttl::n3::{N3Parser, N3Term};

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 rdf_type = N3Term::NamedNode(rdf::TYPE.into_owned());
let schema_person = N3Term::NamedNode(NamedNode::new("http://schema.org/Person")?);
let mut count = 0;
let mut parser = N3Parser::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 {
            count += 1;
        }
    }
}
assert_eq!(2, count);

Trait Implementations

impl Clone for N3Parser

fn clone(&self) -> N3Parser

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for N3Parser

fn default() -> N3Parser

Returns the “default value” for a type.