Struct rio_turtle::NQuadsParser

pub struct NQuadsParser<R: BufRead> { /* fields omitted */ }

A N-Quads streaming parser.

It implements the QuadsParser trait.

Its memory consumption is linear in the size of the longest line of the file. It does not do any allocation during parsing except buffer resizing if a line significantly longer than the previous is encountered.

Count the number of people using the QuadsParser API:

use rio_turtle::{NQuadsParser, TurtleError};
use rio_api::parser::QuadsParser;
use rio_api::model::NamedNode;

let file = b"<http://example.com/foo> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://schema.org/Person> <http://example.com/> .
<http://example.com/foo> <http://schema.org/name> \"Foo\" <http://example.com/> .
<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 rdf_type = NamedNode { iri: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" };
let schema_person = NamedNode { iri: "http://schema.org/Person" };
let mut count = 0;
NQuadsParser::new(file.as_ref()).parse_all(&mut |t| {
    if t.predicate == rdf_type && t.object == schema_person.into() {
        count += 1;
    }
    Ok(()) as Result<(), TurtleError>
})?;
assert_eq!(2, count);

Implementations

impl<R: BufRead> NQuadsParser<R>

pub fn new(reader: R) -> Self

Trait Implementations

impl<B: BufRead> QuadSource for NQuadsParser<B>

type Error = <NQuadsParser<B> as QuadsParser>::Error

The type of errors produced by this source.

type Quad = ScopedRioSourceQuad

Determine the type of Quads that this quad source yields. (see streaming_mode

fn try_for_some_quad<F, EF>(
    &mut self,
    f: &mut F
) -> StreamResult<bool, Self::Error, EF> where
    F: FnMut(StreamedQuad<'_, Self::Quad>) -> Result<(), EF>,
    EF: Error, 

Call f for at least one quad from this quad source, if any.

pub fn try_for_each_quad<F, E>(
    &mut self,
    f: F
) -> Result<(), StreamError<Self::Error, E>> where
    E: Error,
    F: FnMut(StreamedQuad<'_, Self::Quad>) -> Result<(), E>, 

Call f for all quads from this quad source.

pub fn for_some_quad<F>(&mut self, f: &mut F) -> Result<bool, Self::Error> where
    F: FnMut(StreamedQuad<'_, Self::Quad>), 

Call f for at least one quad from this quad source, if any.

pub fn for_each_quad<F>(&mut self, f: F) -> Result<(), Self::Error> where
    F: FnMut(StreamedQuad<'_, Self::Quad>), 

Call f for all quads from this quad source.

pub fn filter_quads<F>(self, filter: F) -> FilterSource<Self, F> where
    F: FnMut(&StreamedQuad<'_, Self::Quad>) -> bool, 

Creates a quad source which uses a closure to determine if a quad should be yielded.

pub fn filter_map_quads<F, T>(self, filter_map: F) -> FilterMapSource<Self, F> where
    F: FnMut(StreamedQuad<'_, Self::Quad>) -> Option<T>, 

Creates a quad source that both filters and maps.

pub fn map_quads<F, T>(self, map: F) -> MapSource<Self, F> where
    F: FnMut(StreamedQuad<'_, Self::Quad>) -> T, 

Takes a closure and creates quad source which yield the result of that closure for each quad.

pub fn size_hint_quads(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the quad source.

pub fn collect_quads<D>(
    self
) -> Result<D, StreamError<Self::Error, <D as Dataset>::Error>> where
    D: CollectibleDataset, 

Collect these quads into a new dataset.

pub fn add_to_dataset<D>(
    self,
    dataset: &mut D
) -> Result<usize, StreamError<Self::Error, <D as MutableDataset>::MutationError>> where
    D: MutableDataset, 

Insert all quads from this source into the given dataset.

impl<R: BufRead> QuadsParser for NQuadsParser<R>

type Error = TurtleError

fn parse_step<E: From<TurtleError>>(
    &mut self,
    on_quad: &mut impl FnMut(Quad<'_>) -> Result<(), E>
) -> Result<(), E>

Parses a small chunk of the file and calls on_quad each time a new quad is read. (A “small chunk” could be a line for an N-Quads parser.)

fn is_end(&self) -> bool

Returns true if the file has been completely consumed by the parser.

pub fn parse_all<E>(
    &mut self,
    on_quad: &mut impl FnMut(Quad<'_>) -> Result<(), E>
) -> Result<(), E> where
    E: From<Self::Error>, 

Parses the complete file and calls on_quad each time a new quad is read.

pub fn into_iter<T, E, F>(
    self,
    convert_quad: F
) -> QuadsParserIterator<T, E, F, Self> where
    E: From<Self::Error>,
    F: FnMut(Quad<'_>) -> Result<T, E>, 

Converts the parser into a Result<T, E> iterator.