Struct rio_xml::RdfXmlParser

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

A RDF XML streaming parser.

It implements the TriplesParser trait. It reads the file in streaming. It does not keep data in memory except a stack for handling nested XML tags, and a set of all seen rdf:IDs to detect duplicate ids and fail according to the specification.

Its performances are not optimized yet and hopefully could be significantly enhanced by reducing the number of allocations and copies done by the parser.

Count the number of people using the TriplesParser API without proper error management:

use rio_xml::{RdfXmlParser, RdfXmlError};
use rio_api::parser::TriplesParser;
use rio_api::model::NamedNode;

let file = b"<?xml version=\"1.0\"?>
<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:schema=\"http://schema.org/\">
 <rdf:Description rdf:about=\"http://example.com/foo\">
   <rdf:type rdf:resource=\"http://schema.org/Person\" />
   <schema:name>Foo</schema:name>
 </rdf:Description>
 <schema:Person rdf:about=\"http://example.com/bar\" schema:name=\"Bar\" />
</rdf:RDF>";

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;
RdfXmlParser::new(file.as_ref(), None).parse_all(&mut |t| {
    if t.predicate == rdf_type && t.object == schema_person.into() {
        count += 1;
    }
    Ok(()) as Result<(), RdfXmlError>
})?;
assert_eq!(2, count);

Implementations

impl<R: BufRead> RdfXmlParser<R>

pub fn new(reader: R, base_iri: Option<Iri<String>>) -> Self

Builds the parser from a BufRead implementation, and a base IRI for relative IRI resolution.

Trait Implementations

impl<B: BufRead> TripleSource for RdfXmlParser<B>

type Error = RdfXmlError

The type of errors produced by this source.

type Triple = ScopedRioSourceTriple

Determine the type of Triples that this triple source yields. (see streaming_mode

fn try_for_some_triple<F, EF>(
    &mut self,
    f: &mut F
) -> StreamResult<bool, Self::Error, EF> where
    F: FnMut(StreamedTriple<'_, Self::Triple>) -> Result<(), EF>,
    EF: Error, 

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

pub fn try_for_each_triple<F, E>(
    &mut self,
    f: F
) -> Result<(), StreamError<Self::Error, E>> where
    E: Error,
    F: FnMut(StreamedTriple<'_, Self::Triple>) -> Result<(), E>, 

Call f for all triples from this triple source.

pub fn for_some_triple<F>(&mut self, f: &mut F) -> Result<bool, Self::Error> where
    F: FnMut(StreamedTriple<'_, Self::Triple>), 

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

pub fn for_each_triple<F>(&mut self, f: F) -> Result<(), Self::Error> where
    F: FnMut(StreamedTriple<'_, Self::Triple>), 

Call f for all triples from this triple source.

pub fn filter_triples<F>(self, filter: F) -> FilterSource<Self, F> where
    F: FnMut(&StreamedTriple<'_, Self::Triple>) -> bool, 

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

pub fn filter_map_triples<F, T>(self, filter_map: F) -> FilterMapSource<Self, F> where
    F: FnMut(StreamedTriple<'_, Self::Triple>) -> Option<T>, 

Creates a triple source that both filters and maps.

pub fn map_triples<F, T>(self, map: F) -> MapSource<Self, F> where
    F: FnMut(StreamedTriple<'_, Self::Triple>) -> T, 

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

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

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

pub fn collect_triples<G>(
    self
) -> Result<G, StreamError<Self::Error, <G as Graph>::Error>> where
    G: CollectibleGraph, 

Collect these triples into a new graph.

pub fn add_to_graph<G>(
    self,
    graph: &mut G
) -> Result<usize, StreamError<Self::Error, <G as MutableGraph>::MutationError>> where
    G: MutableGraph, 

Insert all triples from this source into the given graph.

impl<R: BufRead> TriplesParser for RdfXmlParser<R>

type Error = RdfXmlError

fn parse_step<E: From<RdfXmlError>>(
    &mut self,
    on_triple: &mut impl FnMut(Triple<'_>) -> Result<(), E>
) -> Result<(), E>

Parses a small chunk of the file and calls on_triple each time a new triple is read. (A “small chunk” could be a line for an N-Triples 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_triple: &mut impl FnMut(Triple<'_>) -> Result<(), E>
) -> Result<(), E> where
    E: From<Self::Error>, 

Parses the complete file and calls on_triple each time a new triple is read.

pub fn into_iter<T, E, F>(
    self,
    convert_triple: F
) -> TriplesParserIterator<T, E, F, Self> where
    E: From<Self::Error>,
    F: FnMut(Triple<'_>) -> Result<T, E>, 

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