oxirs-rule 0.2.4

Forward/backward rule engine for RDFS, OWL, and SWRL reasoning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! # RifParser - parsing Methods
//!
//! This module contains method implementations for `RifParser`.
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use anyhow::{anyhow, Result};

use super::types::{RifDocument, RifImport};

use super::rifparser_type::RifParser;

impl RifParser {
    /// Parse Document wrapper
    pub(super) fn parse_document_wrapper(&mut self, doc: &mut RifDocument) -> Result<()> {
        self.skip_ws();
        self.expect("(")?;
        self.skip_ws();
        while !self.try_consume(")") {
            self.skip_ws();
            if self.try_consume("Base") {
                doc.base = Some(self.parse_iri()?);
            } else if self.try_consume("Prefix") {
                let (prefix, iri) = self.parse_prefix_decl()?;
                doc.add_prefix(&prefix, &iri);
                self.prefixes.insert(prefix, iri);
            } else if self.try_consume("Import") {
                doc.imports.push(self.parse_import()?);
            } else if self.try_consume("Group") {
                doc.add_group(self.parse_group()?);
            } else {
                break;
            }
            self.skip_ws();
        }
        Ok(())
    }
    /// Parse prefix declaration: Prefix(prefix <iri>)
    pub(super) fn parse_prefix_decl(&mut self) -> Result<(String, String)> {
        self.skip_ws();
        self.expect("(")?;
        self.skip_ws();
        let prefix = self.parse_name()?;
        self.skip_ws();
        let iri = self.parse_iri()?;
        self.skip_ws();
        self.expect(")")?;
        Ok((prefix, iri))
    }
    /// Parse import directive
    pub(super) fn parse_import(&mut self) -> Result<RifImport> {
        self.skip_ws();
        self.expect("(")?;
        self.skip_ws();
        let location = self.parse_iri()?;
        self.skip_ws();
        let profile = if !self.check(")") {
            Some(self.parse_iri()?)
        } else {
            None
        };
        self.skip_ws();
        self.expect(")")?;
        Ok(RifImport { location, profile })
    }
    /// Parse an IRI: <...>
    pub(super) fn parse_iri(&mut self) -> Result<String> {
        self.skip_ws();
        self.expect("<")?;
        let start = self.pos;
        while self.pos < self.input.len() && !self.check(">") {
            self.pos += 1;
        }
        let iri = self.input[start..self.pos].to_string();
        self.expect(">")?;
        Ok(iri)
    }
    pub(super) fn skip_ws(&mut self) {
        while self.pos < self.input.len() {
            let c = self
                .input
                .chars()
                .nth(self.pos)
                .expect("position is within input bounds");
            if c.is_whitespace() {
                self.pos += 1;
            } else if c == '(' && self.input[self.pos..].starts_with("(*") {
                self.pos += 2;
                while self.pos < self.input.len() - 1 {
                    if self.input[self.pos..].starts_with("*)") {
                        self.pos += 2;
                        break;
                    }
                    self.pos += 1;
                }
            } else {
                break;
            }
        }
    }
    pub(super) fn try_consume(&mut self, s: &str) -> bool {
        if self.check(s) {
            self.pos += s.len();
            true
        } else {
            false
        }
    }
    pub(super) fn expect(&mut self, s: &str) -> Result<()> {
        if self.try_consume(s) {
            Ok(())
        } else {
            Err(anyhow!(
                "Expected '{}' at position {}, found '{}'",
                s,
                self.pos,
                &self.input[self.pos..self.pos.saturating_add(10).min(self.input.len())]
            ))
        }
    }
}