owlish 0.28.0

OWL 2 implementation with wasm support and turtle parsing
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

use crate::parser::matcher::Value;

use crate::rdf_match;

use std::collections::HashMap;

use crate::error::Error;

use super::collector::{CollectedBlankNode, MatcherHandler};

use crate::parser::matcher::RdfMatcher;

pub(crate) fn match_sequences(
    matchers: &mut Vec<(RdfMatcher, MatcherHandler)>,
    prefixes: &HashMap<String, String>,
) -> Result<(), Error> {
    matchers.push((
        rdf_match!("sequences_first", prefixes,
            [:x] [rdf:first] [:object] .
        )?,
        Box::new(|mstate, o, _| {
            if let Some(Value::Blank(bn)) = mstate.get("x") {
                if let Some(object) = mstate.get("object").cloned() {
                    if o.get_blank(bn).is_some() {
                        o.update_blank_node_sequence(bn, Some(object), None);
                    } else {
                        o.insert_blank_node(
                            bn.clone(),
                            CollectedBlankNode::Sequence {
                                first: Some(object),
                                rest: None,
                            },
                        );
                    }
                }
            }
            Ok(false)
        }),
    ));
    matchers.push((
        rdf_match!("sequences_rest", prefixes,
            [:x] [rdf:rest] [:object] .
        )?,
        Box::new(|mstate, o, _| {
            if let Some(Value::Blank(bn)) = mstate.get("x") {
                if let Some(Value::Blank(rest)) = mstate.get("object").cloned() {
                    if o.get_blank(bn).is_some() {
                        o.update_blank_node_sequence(bn, None, Some(rest));
                    } else {
                        o.insert_blank_node(
                            bn.clone(),
                            CollectedBlankNode::Sequence {
                                first: None,
                                rest: Some(rest),
                            },
                        );
                    }
                }
            }
            Ok(false)
        }),
    ));
    Ok(())
}