Struct rio_turtle::NQuadsParser

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

A N-Quads and N-Quads-star 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.

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

Call f for all quads from this quad source.

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.

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.

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.

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.

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.

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

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

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

Collect these quads into a new dataset.

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 MutableDataset.

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.

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.

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.