Struct RdfXmlParser 

pub struct RdfXmlParser { /* private fields */ }

A RDF/XML streaming parser.

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:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxrdfxml::RdfXmlParser;

let file = r#"<?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 schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in RdfXmlParser::new().for_reader(file.as_bytes()) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Implementations

impl RdfXmlParser

pub fn new() -> Self

Builds a new RdfXmlParser.

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

Parses a RDF/XML file from a Read implementation.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxrdfxml::RdfXmlParser;

let file = r#"<?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 schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in RdfXmlParser::new().for_reader(file.as_bytes()) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

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

Parses a RDF/XML file from a byte slice.

Count the number of people:

use oxrdf::NamedNodeRef;
use oxrdf::vocab::rdf;
use oxrdfxml::RdfXmlParser;

let file = r#"<?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 schema_person = NamedNodeRef::new("http://schema.org/Person")?;
let mut count = 0;
for triple in RdfXmlParser::new().for_slice(file) {
    let triple = triple?;
    if triple.predicate == rdf::TYPE && triple.object == schema_person.into() {
        count += 1;
    }
}
assert_eq!(2, count);

Trait Implementations

impl Clone for RdfXmlParser

fn clone(&self) -> RdfXmlParser

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for RdfXmlParser

fn default() -> RdfXmlParser

Returns the “default value” for a type.