srdf/srdf_parser/
rdf_parser.rs

1use super::rdf_parser_error::RDFParseError;
2use super::{rdf_node_parser::*, PResult};
3use crate::matcher::Any;
4use crate::Triple;
5use crate::{FocusRDF, Iri, Query, RDF_TYPE};
6use iri_s::iri;
7use iri_s::IriS;
8use prefixmap::PrefixMap;
9use std::collections::HashSet;
10
11/// The following code is an attempt to define parser combinators where the input is an RDF graph instead of a sequence of characters
12/// Some parts of this code are inspired by [Combine](https://github.com/Marwes/combine)
13///
14/// Represents a generic parser of RDF data
15pub trait RDFParse<RDF: Query> {
16    /// The type which is returned if the parser is successful.
17    type Output;
18
19    fn parse(&mut self, rdf: RDF) -> Result<Self::Output, RDF::Err>;
20}
21
22/// Implements a concrete RDF parser
23pub struct RDFParser<RDF>
24where
25    RDF: FocusRDF,
26{
27    pub rdf: RDF,
28}
29
30impl<RDF> RDFParser<RDF>
31where
32    RDF: FocusRDF,
33{
34    pub fn new(rdf: RDF) -> RDFParser<RDF> {
35        RDFParser { rdf }
36    }
37
38    pub fn prefixmap(&self) -> Option<PrefixMap> {
39        self.rdf.prefixmap()
40    }
41
42    pub fn iri_unchecked(str: &str) -> RDF::IRI {
43        IriS::new_unchecked(str).into()
44    }
45
46    pub fn set_focus(&mut self, focus: &RDF::Term) {
47        self.rdf.set_focus(focus)
48    }
49
50    pub fn set_focus_iri(&mut self, iri: &IriS) {
51        self.rdf.set_focus(&iri.clone().into())
52    }
53
54    pub fn term_iri_unchecked(str: &str) -> RDF::Term {
55        Self::iri_unchecked(str).into()
56    }
57
58    #[inline]
59    fn rdf_type() -> RDF::IRI {
60        RDF_TYPE.clone().into()
61    }
62
63    pub fn instances_of(
64        &self,
65        object: &RDF::Term,
66    ) -> PResult<impl Iterator<Item = RDF::Subject> + '_> {
67        let values = self
68            .rdf
69            .triples_matching(Any, Self::rdf_type(), object.clone())
70            .map_err(|e| RDFParseError::SRDFError { err: e.to_string() })?
71            .map(Triple::into_subject);
72        Ok(values)
73    }
74
75    pub fn instance_of(&self, object: &RDF::Term) -> Result<RDF::Subject, RDFParseError> {
76        let mut values = self.instances_of(object)?;
77        if let Some(value1) = values.next() {
78            if let Some(value2) = values.next() {
79                Err(RDFParseError::MoreThanOneInstanceOf {
80                    object: format!("{object}"),
81                    value1: format!("{value1}"),
82                    value2: format!("{value2}"),
83                })
84            } else {
85                // Only one value
86                Ok(value1)
87            }
88        } else {
89            Err(RDFParseError::NoInstancesOf {
90                object: format!("{object}"),
91            })
92        }
93    }
94
95    pub fn predicate_values(&mut self, pred: &IriS) -> Result<HashSet<RDF::Term>, RDFParseError> {
96        let mut p = property_values(pred);
97        let vs = p.parse_impl(&mut self.rdf)?;
98        Ok(vs)
99    }
100
101    pub fn predicate_value(&mut self, pred: &IriS) -> Result<RDF::Term, RDFParseError>
102    where
103        RDF: FocusRDF,
104    {
105        property_value(pred).parse_impl(&mut self.rdf)
106    }
107
108    pub fn get_rdf_type(&mut self) -> Result<RDF::Term, RDFParseError> {
109        let value = self.predicate_value(&RDF_TYPE)?;
110        Ok(value)
111    }
112
113    pub fn term_as_iri(term: &RDF::Term) -> Result<IriS, RDFParseError> {
114        let iri: RDF::IRI = term
115            .clone()
116            .try_into()
117            .map_err(|_| RDFParseError::ExpectedIRI {
118                term: term.to_string(),
119            })?;
120        let iri_string = iri.as_str();
121        Ok(iri!(iri_string))
122    }
123
124    pub fn term_as_subject(term: &RDF::Term) -> Result<RDF::Subject, RDFParseError> {
125        let subject = term
126            .clone()
127            .try_into()
128            .map_err(|_| RDFParseError::ExpectedSubject {
129                node: format!("{term}"),
130            })?;
131        Ok(subject)
132    }
133
134    pub fn parse_list_for_predicate(
135        &mut self,
136        pred: &IriS,
137    ) -> Result<Vec<RDF::Term>, RDFParseError> {
138        let list_node = self.predicate_value(pred)?;
139        self.rdf.set_focus(&list_node);
140        let values = rdf_list().parse_impl(&mut self.rdf)?;
141        Ok(values)
142    }
143}
srdf/srdf_parser/rdf_parser.rs

srdf/srdf_parser/
rdf_parser.rs
