Debian Codegraph @

Source/Reasoner/Taxonomy/CPCPrSuIpIsDiHierarchyNode.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CPCPrSuIpIsDiHierarchyNode.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Taxonomy {
29
30
31 CPCPrSuIpIsDiHierarchyNode::CPCPrSuIpIsDiHierarchyNode(CConcept *representiveConcept) {
32 eqConList.append(representiveConcept);
33 eqConCount = 1;
34 active = true;
35 mention = false;
36 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
37 generateNodeStrings();
38 #endif
39 }
40
41
42 CPCPrSuIpIsDiHierarchyNode::~CPCPrSuIpIsDiHierarchyNode() {
43 }
44
45
46 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addParentNode(CPCPrSuIpIsDiHierarchyNode *parentNode) {
47 parentNodeSet.insert(parentNode);
48 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
49 generateNodeStrings();
50 #endif
51 return this;
52 }
53
54 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addChildNode(CPCPrSuIpIsDiHierarchyNode *childNode) {
55 childNodeSet.insert(childNode);
56 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
57 generateNodeStrings();
58 #endif
59 return this;
60 }
61
62 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makeParent(CPCPrSuIpIsDiHierarchyNode *parentNode) {
63 parentNodeSet.insert(parentNode);
64 parentNode->addChildNode(this);
65 makePredecessor(parentNode);
66 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
67 generateNodeStrings();
68 #endif
69 return this;
70 }
71
72 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makeChild(CPCPrSuIpIsDiHierarchyNode *childNode) {
73 childNodeSet.insert(childNode);
74 childNode->addParentNode(this);
75 makeSuccessor(childNode);
76 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
77 generateNodeStrings();
78 #endif
79 return this;
80 }
81
82 bool CPCPrSuIpIsDiHierarchyNode::hasChildNode(CPCPrSuIpIsDiHierarchyNode *node) {
83 return childNodeSet.contains(node);
84 }
85
86 bool CPCPrSuIpIsDiHierarchyNode::hasParentNode(CPCPrSuIpIsDiHierarchyNode *node) {
87 return parentNodeSet.contains(node);
88 }
89
90
91 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addEquivalentConcept(CConcept *concept) {
92 eqConList.append(concept);
93 eqConCount++;
94 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
95 generateNodeStrings();
96 #endif
97 return this;
98 }
99
100 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addPredecessorNode(CPCPrSuIpIsDiHierarchyNode *preNode) {
101 predNodeSet.insert(preNode);
102 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
103 generateNodeStrings();
104 #endif
105 return this;
106 }
107
108 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addSuccessorNode(CPCPrSuIpIsDiHierarchyNode *succNode) {
109 succNodeSet.insert(succNode);
110 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
111 generateNodeStrings();
112 #endif
113 return this;
114 }
115
116
117 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makePredecessor(CPCPrSuIpIsDiHierarchyNode *preNode) {
118 predNodeSet.insert(preNode);
119 preNode->addSuccessorNode(this);
120 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
121 generateNodeStrings();
122 #endif
123 return this;
124 }
125
126 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makeSuccessor(CPCPrSuIpIsDiHierarchyNode *succNode) {
127 succNodeSet.insert(succNode);
128 succNode->addPredecessorNode(this);
129 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
130 generateNodeStrings();
131 #endif
132 return this;
133 }
134
135
136 bool CPCPrSuIpIsDiHierarchyNode::hasSuccessorNode(CPCPrSuIpIsDiHierarchyNode *node) {
137 return succNodeSet.contains(node);
138 }
139
140 bool CPCPrSuIpIsDiHierarchyNode::hasPredecessorNode(CPCPrSuIpIsDiHierarchyNode *node) {
141 return predNodeSet.contains(node);
142 }
143
144
145
146 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removeParent(CPCPrSuIpIsDiHierarchyNode *parentNode) {
147 parentNodeSet.remove(parentNode);
148 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
149 generateNodeStrings();
150 #endif
151 return this;
152 }
153
154 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removeChild(CPCPrSuIpIsDiHierarchyNode *childNode) {
155 childNodeSet.remove(childNode);
156 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
157 generateNodeStrings();
158 #endif
159 return this;
160 }
161
162
163
164 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getParentNodeSet() {
165 return &parentNodeSet;
166 }
167
168 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getChildNodeSet() {
169 return &childNodeSet;
170 }
171
172 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getPredecessorNodeSet() {
173 return &predNodeSet;
174 }
175
176 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getSuccessorNodeSet() {
177 return &succNodeSet;
178 }
179
180 QList<CConcept *> *CPCPrSuIpIsDiHierarchyNode::getEquivalentConceptList() {
181 return &eqConList;
182 }
183
184
185 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removePredecessor(CPCPrSuIpIsDiHierarchyNode *predNode) {
186 predNodeSet.remove(predNode);
187 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
188 generateNodeStrings();
189 #endif
190 return this;
191 }
192
193 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removeSuccessor(CPCPrSuIpIsDiHierarchyNode *succNode) {
194 succNodeSet.remove(succNode);
195 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
196 generateNodeStrings();
197 #endif
198 return this;
199 }
200
201 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getParentNodeList() {
202 return parentNodeSet.values();
203 }
204
205 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getChildNodeList() {
206 return childNodeSet.values();
207 }
208
209 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getPredecessorNodeList() {
210 return predNodeSet.values();
211 }
212
213 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getSuccessorNodeList() {
214 return succNodeSet.values();
215 }
216
217
218
219 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addIncompatiblePredecessorNode(CPCPrSuIpIsDiHierarchyNode *incompNode) {
220 incompPredNodeSet.insert(incompNode);
221 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
222 generateNodeStrings();
223 #endif
224 return this;
225 }
226
227 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makeIncompatiblePredecessor(CPCPrSuIpIsDiHierarchyNode *incompNode) {
228 addIncompatiblePredecessorNode(incompNode);
229 incompNode->addIncompatibleSuccessorNode(this);
230 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
231 generateNodeStrings();
232 #endif
233 return this;
234 }
235
236 bool CPCPrSuIpIsDiHierarchyNode::hasIncompatiblePredecessorNode(CPCPrSuIpIsDiHierarchyNode *node) {
237 return incompPredNodeSet.contains(node);
238 }
239
240
241 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removeIncompatiblePredecessorNode(CPCPrSuIpIsDiHierarchyNode *incompNode) {
242 incompPredNodeSet.remove(incompNode);
243 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
244 generateNodeStrings();
245 #endif
246 return this;
247 }
248
249 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addIncompatibleSuccessorNode(CPCPrSuIpIsDiHierarchyNode *incompNode) {
250 incompSuccNodeSet.insert(incompNode);
251 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
252 generateNodeStrings();
253 #endif
254 return this;
255 }
256
257 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makeIncompatibleSuccessor(CPCPrSuIpIsDiHierarchyNode *incompNode) {
258 addIncompatibleSuccessorNode(incompNode);
259 incompNode->addIncompatiblePredecessorNode(this);
260 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
261 generateNodeStrings();
262 #endif
263 return this;
264 }
265
266 bool CPCPrSuIpIsDiHierarchyNode::hasIncompatibleSuccessorNode(CPCPrSuIpIsDiHierarchyNode *node) {
267 return incompSuccNodeSet.contains(node);
268 }
269
270 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removeIncompatibleSuccessorNode(CPCPrSuIpIsDiHierarchyNode *incompNode) {
271 incompSuccNodeSet.remove(incompNode);
272 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
273 generateNodeStrings();
274 #endif
275 return this;
276 }
277
278
279
280 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::addDisjointNode(CPCPrSuIpIsDiHierarchyNode *disjNode) {
281 disjointNodeSet.insert(disjNode);
282 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
283 generateNodeStrings();
284 #endif
285 return this;
286 }
287
288 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::makeDisjoint(CPCPrSuIpIsDiHierarchyNode *disjNode) {
289 addDisjointNode(disjNode);
290 disjNode->addDisjointNode(this);
291 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
292 generateNodeStrings();
293 #endif
294 return this;
295 }
296
297 bool CPCPrSuIpIsDiHierarchyNode::hasDisjointNode(CPCPrSuIpIsDiHierarchyNode *node) {
298 return disjointNodeSet.contains(node);
299 }
300
301 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::removeDisjointNode(CPCPrSuIpIsDiHierarchyNode *disjNode) {
302 disjointNodeSet.remove(disjNode);
303 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
304 generateNodeStrings();
305 #endif
306 return this;
307 }
308
309
310
311
312 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getIncompatibleSuccessorNodeSet() {
313 return &incompSuccNodeSet;
314 }
315
316 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getIncompatiblePredecessorNodeSet() {
317 return &incompPredNodeSet;
318 }
319
320
321 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getIncompatibleSuccessorNodeList() {
322 return incompSuccNodeSet.values();
323 }
324
325 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getIncompatiblePredecessorNodeList() {
326 return incompPredNodeSet.values();
327 }
328
329
330
331 QSet<CPCPrSuIpIsDiHierarchyNode *> *CPCPrSuIpIsDiHierarchyNode::getDisjointNodeSet() {
332 return &disjointNodeSet;
333 }
334
335 QList<CPCPrSuIpIsDiHierarchyNode *> CPCPrSuIpIsDiHierarchyNode::getDisjointNodeList() {
336 return disjointNodeSet.values();
337 }
338
339
340 CConcept *CPCPrSuIpIsDiHierarchyNode::getOneEquivalentConcept() {
341 CConcept *concept = 0;
342 if (!eqConList.isEmpty()) {
343 concept = eqConList.first();
344 }
345 return concept;
346 }
347
348
349 bool CPCPrSuIpIsDiHierarchyNode::isActive() {
350 return active;
351 }
352
353 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::setActive(bool activeNode) {
354 active = activeNode;
355 return this;
356 }
357
358 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::setInactive(bool inactiveNode) {
359 active = !inactiveNode;
360 return this;
361 }
362
363
364 bool CPCPrSuIpIsDiHierarchyNode::isNeedExplicitMentioned() {
365 return mention;
366 }
367
368 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::setNeedExplicitMentioned(bool needsExplicitMentioned) {
369 mention = needsExplicitMentioned;
370 return this;
371 }
372
373
374
375
376 QString CPCPrSuIpIsDiHierarchyNode::getEquivalentConceptsNodeString() {
377 QString string;
378 foreach (CConcept *con, eqConList) {
379 QString iriClassNameString = CIRIName::getRecentIRIName(con->getClassNameLinker());
380 if (!string.isEmpty()) {
381 string += QString(" <=> %1").arg(iriClassNameString);
382 } else {
383 string = iriClassNameString;
384 }
385 }
386 return string;
387 }
388
389
390 QString CPCPrSuIpIsDiHierarchyNode::getHierarchyConceptsNodeString(qint64 depth) {
391 QString string(depth,'\t');
392 string += QString("< ") + getEquivalentConceptsNodeString() + QString(" >\n");
393 foreach (CPCPrSuIpIsDiHierarchyNode *childNode, getChildNodeList()) {
394 string += childNode->getHierarchyConceptsNodeString(depth+1);
395 }
396 string += QString(depth,'\t')+QString("</ ") + getEquivalentConceptsNodeString() + QString(" >\n");
397 return string;
398 }
399
400
401 QStringList CPCPrSuIpIsDiHierarchyNode::getEquivalentConceptStringList(bool preferAbbreviatedNames) {
402 QStringList stringList;
403 foreach (CConcept *con, eqConList) {
404 QStringList iriClassNameStringList;
405 if (preferAbbreviatedNames) {
406 iriClassNameStringList = CAbbreviatedIRIName::getAbbreviatedPrefixWithAbbreviatedIRINames(con->getClassNameLinker());
407 }
408
409 if (!preferAbbreviatedNames || iriClassNameStringList.isEmpty()) {
410 iriClassNameStringList = CIRIName::getIRINames(con->getClassNameLinker());
411 }
412 stringList<<iriClassNameStringList;
413 }
414 return stringList;
415 }
416
417
418 qint64 CPCPrSuIpIsDiHierarchyNode::getEquivalentConceptCount() {
419 return eqConCount;
420 }
421
422
423 #ifdef DEBUGCPCPRSUIPISDIHIERARCHYNODECONCEPTSTRINGS
424 CPCPrSuIpIsDiHierarchyNode *CPCPrSuIpIsDiHierarchyNode::generateNodeStrings() {
425 nodeStrings.clear();
426 nodeStrings = getEquivalentConceptStringList(true);
427 parentNodeStrings.clear();
428 foreach (CPCPrSuIpIsDiHierarchyNode *node, getParentNodeList()) {
429 parentNodeStrings<<node->getEquivalentConceptsNodeString();
430 }
431 childNodeStrings.clear();
432 foreach (CPCPrSuIpIsDiHierarchyNode *node, getChildNodeList()) {
433 childNodeStrings<<node->getEquivalentConceptsNodeString();
434 }
435 precNodeStrings.clear();
436 foreach (CPCPrSuIpIsDiHierarchyNode *node, getPredecessorNodeList()) {
437 precNodeStrings<<node->getEquivalentConceptsNodeString();
438 }
439 succNodeStrings.clear();
440 foreach (CPCPrSuIpIsDiHierarchyNode *node, getSuccessorNodeList()) {
441 succNodeStrings<<node->getEquivalentConceptsNodeString();
442 }
443 incPrecNodeStrings.clear();
444 foreach (CPCPrSuIpIsDiHierarchyNode *node, getIncompatiblePredecessorNodeList()) {
445 incPrecNodeStrings<<node->getEquivalentConceptsNodeString();
446 }
447 incSuccNodeStrings.clear();
448 foreach (CPCPrSuIpIsDiHierarchyNode *node, getIncompatibleSuccessorNodeList()) {
449 incSuccNodeStrings<<node->getEquivalentConceptsNodeString();
450 }
451 disjointNodeStrings.clear();
452 foreach (CPCPrSuIpIsDiHierarchyNode *node, getDisjointNodeList()) {
453 disjointNodeStrings<<node->getEquivalentConceptsNodeString();
454 }
455 return this;
456 }
457 #endif
458
459
460 }; // end namespace Taxonomy
461
462 }; // end namespace Reasoner
463
464 }; // end namespace Konclude