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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
use crate::individual::*;
use std::collections::{HashMap, HashSet};
use std::fmt;
#[derive(PartialEq, Debug)]
pub enum RelType {
Sub,
Super,
}
#[derive(Debug)]
pub struct Onto {
pub relations: HashMap<String, HashMap<String, RelType>>,
pub prefixes: HashMap<String, String>,
}
impl fmt::Display for Onto {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:#?}", self.relations)
}
}
impl Default for Onto {
fn default() -> Self {
Onto {
relations: HashMap::new(),
prefixes: HashMap::new(),
}
}
}
impl Onto {
pub fn update(&mut self, indv: &mut Individual) -> bool {
if let Some(vtype) = indv.get_first_literal("rdf:type") {
if vtype == "owl:Class"
|| vtype == "rdfs:Class"
|| vtype == "rdf:Property"
|| vtype == "rdfs:Datatype"
|| vtype == "owl:ObjectProperty"
|| vtype == "owl:DatatypeProperty"
{
let subs = if vtype == "owl:Class" || vtype == "rdfs:Class" {
if let Some(_subclasses) = indv.get_literals("rdfs:subClassOf") {
_subclasses
} else {
Vec::new()
}
} else if vtype == "rdf:Property" || vtype == "owl:ObjectProperty" || vtype == "owl:DatatypeProperty" {
if let Some(_subproperties) = indv.get_literals("rdfs:subPropertyOf") {
_subproperties
} else {
Vec::new()
}
} else {
Vec::new()
};
let onto_el = self.relations.entry(indv.obj.uri.clone()).or_default();
for sub in subs.clone() {
let rel_type = onto_el.entry(sub).or_insert(RelType::Super);
*rel_type = RelType::Super;
}
for sub in subs {
let onto_el = self.relations.entry(sub).or_default();
let rel_type = onto_el.entry(indv.obj.uri.clone()).or_insert(RelType::Sub);
*rel_type = RelType::Sub;
}
} else if vtype == "owl:Ontology" {
if let Some(full_url) = indv.get_first_literal("v-s:fullUrl") {
debug!("prefix : {} -> {}", indv.get_id(), full_url);
self.prefixes.insert(indv.get_id().to_owned(), full_url);
}
} else {
debug!("is not onto element: {}", indv.obj.uri)
}
}
true
}
pub fn is_some_entered(&mut self, el: &str, subs: &[&str]) -> bool {
for sub in subs {
if self.relations.contains_key(*sub) {
let onto_el = self.relations.entry((*sub).to_string()).or_default();
if let Some(rtype) = onto_el.get(el) {
if *rtype == RelType::Sub {
return true;
}
}
}
}
false
}
pub fn is_some_entered_it<'a, I>(&mut self, el: &str, subs: I) -> bool
where
I: Iterator<Item = &'a String>,
{
for sub in subs {
if self.relations.contains_key(sub) {
let onto_el = self.relations.entry((*sub).to_string()).or_default();
if let Some(rtype) = onto_el.get(el) {
if *rtype == RelType::Sub {
return true;
}
}
}
}
false
}
pub fn get_subs(&self, el: &str, collector: &mut HashSet<String>) {
if self.relations.contains_key(el) {
let mut buf = Vec::new();
if let Some(qqq) = self.relations.get(el) {
for (x, t) in qqq {
if *t == RelType::Sub && !collector.contains(x) {
collector.insert(x.to_string());
buf.push(x.to_string());
}
}
}
for x in buf {
self.get_subs(&x, collector);
}
}
}
pub fn get_supers(&self, el: &str, collector: &mut HashSet<String>) {
if self.relations.contains_key(el) {
let mut buf = Vec::new();
if let Some(qqq) = self.relations.get(el) {
for (x, t) in qqq {
if *t == RelType::Super && !collector.contains(x) {
collector.insert(x.to_string());
buf.push(x.to_string());
}
}
}
for x in buf {
self.get_supers(&x, collector);
}
}
}
pub fn update_subs(&mut self, el: &str, subs: &mut HashSet<String>) {
if self.relations.contains_key(el) {
let onto_el = self.relations.entry(el.to_string()).or_default();
for sub in subs.iter() {
let rel_type = onto_el.entry(sub.to_string()).or_insert(RelType::Sub);
*rel_type = RelType::Sub;
}
}
}
pub fn get_full_prefix(&self, short_prefix: &str) -> Option<&String> {
self.prefixes.get(short_prefix)
}
}