Debian Codegraph @

Source/Reasoner/Ontology/CRole.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 "CRole.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CRole::CRole() {
32 initRole();
33 }
34
35
36
37 CRole *CRole::initRole() {
38 superRoles = 0;
39 indirectSuperRoles = 0;
40 mComplexity = false;
41 mFunctional = false;
42 mInvFunctional = false;
43 mTransetive = false;
44 mAsymmetric = false;
45 mSymmetric = false;
46 mReflexive = false;
47 mIrreflexive = false;
48 mDataRole = false;
49 rangeLinker = 0;
50 domainLinker = 0;
51 tax = 0;
52 mInverseEquivalentRoles = 0;
53 mDisjointRoles = 0;
54 mRoleChainSubSharingLinker = nullptr;
55 mRoleChainSuperSharingLinker = nullptr;
56 mInverseRole = nullptr;
57 mRoleData = nullptr;
58 return this;
59 }
60
61
62 CRole *CRole::init(qint64 roleTag) {
63 initRole();
64 mTag = roleTag;
65 return this;
66 }
67
68
69 CRole *CRole::init(CRole *role) {
70 mNameLinker = role->getPropertyNameLinker();
71 mTag = role->mTag;
72 mDataRole = role->mDataRole;
73 superRoles = 0;
74 indirectSuperRoles = 0;
75 rangeLinker = 0;
76 domainLinker = 0;
77 tax = 0;
78 mInverseEquivalentRoles = 0;
79 mDisjointRoles = 0;
80 mInverseRole = nullptr;
81 mComplexity = role->mComplexity;
82 mFunctional = role->mFunctional;
83 mInvFunctional = role->mInvFunctional;
84 mTransetive = role->mTransetive;
85 mAsymmetric = role->mAsymmetric;
86 mSymmetric = role->mSymmetric;
87 mReflexive = role->mReflexive;
88 mIrreflexive = role->mIrreflexive;
89 mRoleChainSubSharingLinker = role->mRoleChainSubSharingLinker;
90 mRoleChainSuperSharingLinker = role->mRoleChainSuperSharingLinker;
91 return this;
92 }
93
94
95
96 CRole *CRole::initRoleCopy(CRole *role, CMemoryAllocationManager* memMan) {
97 mNameLinker = role->getPropertyNameLinker();
98 mTag = role->mTag;
99 mDataRole = role->mDataRole;
100 superRoles = 0;
101 indirectSuperRoles = 0;
102 rangeLinker = 0;
103 domainLinker = 0;
104 tax = 0;
105 mInverseEquivalentRoles = 0;
106 mDisjointRoles = 0;
107 mComplexity = role->mComplexity;
108 mFunctional = role->mFunctional;
109 mInvFunctional = role->mInvFunctional;
110 mTransetive = role->mTransetive;
111 mAsymmetric = role->mAsymmetric;
112 mSymmetric = role->mSymmetric;
113 mReflexive = role->mReflexive;
114 mIrreflexive = role->mIrreflexive;
115 mRoleChainSubSharingLinker = role->mRoleChainSubSharingLinker;
116 mRoleChainSuperSharingLinker = role->mRoleChainSuperSharingLinker;
117 mInverseRole = role->mInverseRole;
118
119 CSortedNegLinker<CRole *> *superRoleIt = role->superRoles;
120 while (superRoleIt) {
121 CRole *superRole = superRoleIt->getData();
122 bool negated = superRoleIt->isNegated();
123 CSortedNegLinker<CRole *> *superRoleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(memMan);
124 superRoleLinker->init(superRole,negated);
125 addSuperRoleLinker(superRoleLinker);
126 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
127 }
128
129 CSortedNegLinker<CRole *> *inverseRolesIt = role->getInverseRoleList();
130 while (inverseRolesIt) {
131 CSortedNegLinker<CRole *> *invRoleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(memMan);
132 invRoleLinker->init(inverseRolesIt->getData(),inverseRolesIt->isNegated());
133 addInverseRoleLinker(invRoleLinker);
134 inverseRolesIt = (CSortedNegLinker<CRole *> *)inverseRolesIt->getNext();
135 }
136
137 CSortedNegLinker<CRole *> *disjointRolesIt = role->getDisjointRoleList();
138 while (disjointRolesIt) {
139 CSortedNegLinker<CRole *> *disRoleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(memMan);
140 disRoleLinker->init(disjointRolesIt->getData(),disjointRolesIt->isNegated());
141 addDisjointRoleLinker(disRoleLinker);
142 disjointRolesIt = (CSortedNegLinker<CRole *> *)disjointRolesIt->getNext();
143 }
144
145 CSortedNegLinker<CConcept *> *rangeLinkerIt = role->getRangeConceptList();
146 while (rangeLinkerIt) {
147 CSortedNegLinker<CConcept *> *rangeConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(memMan);
148 rangeConLinker->init(rangeLinkerIt->getData(),rangeLinkerIt->isNegated());
149 addRangeConceptLinker(rangeConLinker);
150 rangeLinkerIt = (CSortedNegLinker<CConcept *> *)rangeLinkerIt->getNext();
151 }
152
153 CSortedNegLinker<CConcept *> *domainLinkerIt = role->getDomainConceptList();
154 while (domainLinkerIt) {
155 CSortedNegLinker<CConcept *> *domainConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(memMan);
156 domainConLinker->init(domainLinkerIt->getData(),domainLinkerIt->isNegated());
157 addDomainConceptLinker(domainConLinker);
158 domainLinkerIt = (CSortedNegLinker<CConcept *> *)domainLinkerIt->getNext();
159 }
160
161 return this;
162 }
163
164
165
166 bool CRole::isDataRole() {
167 return mDataRole;
168 }
169
170 bool CRole::isObjectRole() {
171 return !isDataRole();
172 }
173
174 CRole* CRole::setDataRole(bool dataRole) {
175 mDataRole = dataRole;
176 return this;
177 }
178
179 CRole* CRole::setObjectRole(bool objectRole) {
180 setDataRole(!objectRole);
181 return this;
182 }
183
184
185
186 CRole* CRole::getInverseRole() {
187 return mInverseRole;
188 }
189
190 CRole* CRole::setInverseRole(CRole* inverseRole) {
191 mInverseRole = inverseRole;
192 return this;
193 }
194
195
196 bool CRole::hasInverseRoles() {
197 if (mInverseRole) {
198 return true;
199 }
200 CSortedNegLinker<CRole*>* inverseEquivalentRolesIt = mInverseEquivalentRoles;
201 while (inverseEquivalentRolesIt) {
202 if (inverseEquivalentRolesIt->isNegated()) {
203 return true;
204 }
205 inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext();
206 }
207 return false;
208 }
209
210
211
212 CRole *CRole::addInverseRoleLinker(CSortedNegLinker<CRole *> *inverseRole) {
213 if (mInverseEquivalentRoles) {
214 mInverseEquivalentRoles = mInverseEquivalentRoles->insertSortedNextSorted(inverseRole);
215 } else {
216 mInverseEquivalentRoles = inverseRole;
217 }
218 return this;
219 }
220
221 CSortedNegLinker<CRole *> *CRole::getInverseRoleList() {
222 return mInverseEquivalentRoles;
223 }
224
225
226 CRole *CRole::setInverseEquivalentRoleList(CSortedNegLinker<CRole *> *invEqRoleList) {
227 mInverseEquivalentRoles = invEqRoleList;
228 return this;
229 }
230
231
232 CSortedNegLinker<CRole *> *CRole::getInverseEquivalentRoleList() {
233 return mInverseEquivalentRoles;
234 }
235
236
237 bool CRole::hasEquivalentRoles() {
238 CSortedNegLinker<CRole*>* inverseEquivalentRolesIt = mInverseEquivalentRoles;
239 while (inverseEquivalentRolesIt) {
240 if (!inverseEquivalentRolesIt->isNegated()) {
241 return true;
242 }
243 inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext();
244 }
245 return false;
246 }
247
248 CRole *CRole::addEquivalentRoleLinker(CSortedNegLinker<CRole *> *equivalentRole) {
249 if (mInverseEquivalentRoles) {
250 mInverseEquivalentRoles = mInverseEquivalentRoles->insertSortedNextSorted(equivalentRole);
251 } else {
252 mInverseEquivalentRoles = equivalentRole;
253 }
254 return this;
255 }
256
257 bool CRole::hasEquivalentRole(CRole* role) {
258 CSortedNegLinker<CRole*>* inverseEquivalentRolesIt = mInverseEquivalentRoles;
259 while (inverseEquivalentRolesIt) {
260 if (!inverseEquivalentRolesIt->isNegated() && inverseEquivalentRolesIt->getData() == role) {
261 return true;
262 }
263 inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext();
264 }
265 return false;
266 }
267
268 bool CRole::hasInverseRole(CRole* role) {
269 if (mInverseRole == role) {
270 return true;
271 }
272 CSortedNegLinker<CRole*>* inverseEquivalentRolesIt = mInverseEquivalentRoles;
273 while (inverseEquivalentRolesIt) {
274 if (inverseEquivalentRolesIt->isNegated() && inverseEquivalentRolesIt->getData() == role) {
275 return true;
276 }
277 inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext();
278 }
279 return false;
280 }
281
282 bool CRole::hasDisjointRole(CRole* role) {
283 CSortedNegLinker<CRole*>* disjointRolesIt = mDisjointRoles;
284 while (disjointRolesIt) {
285 if (disjointRolesIt->getData() == role) {
286 return true;
287 }
288 disjointRolesIt = disjointRolesIt->getNext();
289 }
290 return false;
291 }
292
293
294 CRole *CRole::setDisjointRoleList(CSortedNegLinker<CRole *> *disRoleList) {
295 mDisjointRoles = disRoleList;
296 return this;
297 }
298
299
300
301 bool CRole::hasDisjointRoles() {
302 return mDisjointRoles != nullptr;
303 }
304
305 CRole *CRole::addDisjointRoleLinker(CSortedNegLinker<CRole *> *disjointRole) {
306 if (mDisjointRoles) {
307 mDisjointRoles = mDisjointRoles->insertSortedNextSorted(disjointRole);
308 } else {
309 mDisjointRoles = disjointRole;
310 }
311 return this;
312 }
313
314 CSortedNegLinker<CRole *> *CRole::getDisjointRoleList() {
315 return mDisjointRoles;
316 }
317
318
319 CSortedNegLinker<CRole *> *CRole::getEquivalentRoleList() {
320 return mInverseEquivalentRoles;
321 }
322
323 CRole *CRole::setRoleTag(qint64 roleTag) {
324 mTag = roleTag;
325 return this;
326 }
327
328 qint64 CRole::getRoleTag() const {
329 return mTag;
330 }
331
332 CRole *CRole::setTerminology(CTerminology *ontology) {
333 tax = ontology;
334 return this;
335 }
336
337 CTerminology *CRole::getTerminology() {
338 return tax;
339 }
340
341
342 qint64 CRole::getTerminologyTag() const {
343 if (tax) {
344 return tax->getTerminologyID();
345 } else {
346 return 0;
347 }
348 }
349
350
351 CRole *CRole::setRoleComplexity(bool complexRole) {
352 mComplexity = complexRole;
353 return this;
354 }
355
356 bool CRole::isComplexRole() {
357 return mComplexity;
358 }
359
360 bool CRole::isSimpleRole() {
361 return !mComplexity;
362 }
363
364 bool CRole::getRoleComplexity() {
365 return mComplexity;
366 }
367
368 CRole *CRole::setFunctional(bool functional) {
369 mFunctional = functional;
370 return this;
371 }
372
373 bool CRole::isFunctional() {
374 return mFunctional;
375 }
376
377 bool CRole::getFunctional() {
378 return mFunctional;
379 }
380
381 CRole *CRole::setInverseFunctional(bool invFunctional) {
382 mInvFunctional = invFunctional;
383 return this;
384 }
385
386 bool CRole::isInverseFunctional() {
387 return mInvFunctional;
388 }
389
390 bool CRole::getInverseFunctional() {
391 return mInvFunctional;
392 }
393
394 CRole *CRole::setTransitive(bool transetive) {
395 mTransetive = transetive;
396 return this;
397 }
398
399 bool CRole::isTransitive() {
400 return mTransetive;
401 }
402
403 bool CRole::getTransitive() {
404 return isTransitive();
405 }
406
407 bool CRole::hasRoleData() {
408 return mRoleData != nullptr;
409 }
410
411 CRoleData* CRole::getRoleData() {
412 return mRoleData;
413 }
414
415 CRole* CRole::setRoleData(CRoleData* roleData) {
416 mRoleData = roleData;
417 return this;
418 }
419
420
421 CRole *CRole::setAsymmetric(bool asymmetric) {
422 mAsymmetric = asymmetric;
423 return this;
424 }
425
426 bool CRole::isAsymmetric() {
427 return mAsymmetric;
428 }
429
430 bool CRole::getAsymmetric() {
431 return mAsymmetric;
432 }
433
434 CRole *CRole::setSymmetric(bool symmetric) {
435 mSymmetric = symmetric;
436 return this;
437 }
438
439 bool CRole::isSymmetric() {
440 return mSymmetric;
441 }
442
443 bool CRole::getSymmetric() {
444 return mSymmetric;
445 }
446
447 CRole *CRole::setReflexive(bool reflexive) {
448 mReflexive = reflexive;
449 return this;
450 }
451
452 bool CRole::isReflexive() {
453 return mReflexive;
454 }
455
456 bool CRole::getReflexive() {
457 return mReflexive;
458 }
459
460
461 CRole *CRole::setIrreflexive(bool irreflexive) {
462 mIrreflexive = irreflexive;
463 return this;
464 }
465
466 bool CRole::isIrreflexive() {
467 return mIrreflexive;
468 }
469
470 bool CRole::getIrreflexive() {
471 return mIrreflexive;
472 }
473
474
475
476 CSortedNegLinker<CConcept *> *CRole::getRangeConceptList() {
477 return rangeLinker;
478 }
479
480
481 CSortedNegLinker<CConcept *> *CRole::getRelativeRangeConceptList(bool roleInversed) {
482 if (roleInversed) {
483 return domainLinker;
484 } else {
485 return rangeLinker;
486 }
487 }
488
489 CSortedNegLinker<CConcept *> *CRole::getDomainRangeConceptList(bool roleInversed) {
490 if (roleInversed) {
491 return rangeLinker;
492 } else {
493 return domainLinker;
494 }
495 }
496
497
498
499 bool CRole::hasRangeConceptTag(qint64 rangeConceptTag) {
500 CSortedNegLinker<CConcept *> *rangeConIt = rangeLinker;
501 while (rangeConIt) {
502 qint64 rangeConTag = rangeConIt->getData()->getConceptTag();
503 if (rangeConTag == rangeConceptTag) {
504 return true;
505 } else if (rangeConTag > rangeConceptTag) {
506 return false;
507 }
508 rangeConIt = (CSortedNegLinker<CConcept *> *)rangeConIt->getNext();
509 }
510 return false;
511 }
512
513 bool CRole::hasRangeConcept(CConcept* concept) {
514 CSortedNegLinker<CConcept *> *rangeConIt = rangeLinker;
515 while (rangeConIt) {
516 CConcept* rangeConcept = rangeConIt->getData();
517 if (rangeConcept == concept) {
518 return true;
519 }
520 rangeConIt = (CSortedNegLinker<CConcept *> *)rangeConIt->getNext();
521 }
522 return false;
523 }
524
525
526
527 bool CRole::hasDomainConcept(CConcept* concept) {
528 CSortedNegLinker<CConcept *> *domainConIt = domainLinker;
529 while (domainConIt) {
530 CConcept* domainConcept = domainConIt->getData();
531 if (domainConcept == concept) {
532 return true;
533 }
534 domainConIt = (CSortedNegLinker<CConcept *> *)domainConIt->getNext();
535 }
536 return false;
537 }
538
539
540 bool CRole::hasDomainConceptTag(qint64 domainConceptTag) {
541 CSortedNegLinker<CConcept *> *domainConIt = domainLinker;
542 while (domainConIt) {
543 qint64 domainConTag = domainConIt->getData()->getConceptTag();
544 if (domainConTag == domainConceptTag) {
545 return true;
546 } else if (domainConTag > domainConceptTag) {
547 return false;
548 }
549 domainConIt = (CSortedNegLinker<CConcept *> *)domainConIt->getNext();
550 }
551 return false;
552 }
553
554
555 bool CRole::hasDomainOrRangeConceptTag(qint64 conceptTag) {
556 return hasRangeConceptTag(conceptTag) || hasDomainConceptTag(conceptTag);
557 }
558
559
560
561 CRole *CRole::setRangeConceptList(CSortedNegLinker<CConcept *> *rangeConceptList) {
562 rangeLinker = rangeConceptList;
563 return this;
564 }
565
566 CRole *CRole::addRangeConceptLinker(CSortedNegLinker<CConcept *> *rangeConceptLinker) {
567 if (rangeLinker) {
568 rangeLinker = rangeLinker->insertSortedNextSorted(rangeConceptLinker);
569 } else {
570 rangeLinker = rangeConceptLinker;
571 }
572 return this;
573 }
574
575
576 CSortedNegLinker<CConcept *> *CRole::getDomainConceptList() {
577 return domainLinker;
578 }
579
580 CRole *CRole::setDomainConceptList(CSortedNegLinker<CConcept *> *domainConceptList) {
581 domainLinker = domainConceptList;
582 return this;
583 }
584
585 CRole *CRole::addDomainConceptLinker(CSortedNegLinker<CConcept *> *domainConceptLinker) {
586 if (domainLinker) {
587 domainLinker = domainLinker->insertSortedNextSorted(domainConceptLinker);
588 } else {
589 domainLinker = domainConceptLinker;
590 }
591 return this;
592 }
593
594
595
596 CRole *CRole::setSuperRoleList(CSortedNegLinker<CRole *> *superRoleList) {
597 superRoles = superRoleList;
598 return this;
599 }
600
601
602 CRole *CRole::addSuperRoleLinker(CSortedNegLinker<CRole *> *superRoleLinker) {
603 if (superRoles) {
604 superRoles = superRoles->insertSortedNextSorted(superRoleLinker);
605 } else {
606 superRoles = superRoleLinker;
607 }
608 return this;
609 }
610
611
612 CSortedNegLinker<CRole *> *CRole::getSuperRoleList() {
613 return superRoles;
614 }
615
616
617 bool CRole::hasSuperRole(CRole* role) {
618 CSortedNegLinker<CRole *> *superRoleIt = superRoles;
619 while (superRoleIt) {
620 CRole *superRole = superRoleIt->getData();
621 if (superRole == role) {
622 return true;
623 }
624 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
625 }
626 return false;
627 }
628
629
630 bool CRole::hasSuperRoleTag(qint64 tag) {
631 CSortedNegLinker<CRole *> *superRoleIt = superRoles;
632 while (superRoleIt) {
633 CRole *superRole = superRoleIt->getData();
634 qint64 superRoleTag = superRole->getRoleTag();
635 if (tag == superRoleTag) {
636 return true;
637 } else if (superRoleTag > tag) {
638 return false;
639 }
640 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
641 }
642 return false;
643 }
644
645
646 bool CRole::hasSuperRoleTag(qint64 tag, bool negated) {
647 CSortedNegLinker<CRole *> *superRoleIt = superRoles;
648 while (superRoleIt) {
649 CRole *superRole = superRoleIt->getData();
650 qint64 superRoleTag = superRole->getRoleTag();
651 if (tag == superRoleTag && superRoleIt->isNegated() == negated) {
652 return true;
653 } else if (superRoleTag > tag) {
654 return false;
655 }
656 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
657 }
658 return false;
659 }
660
661 CRole *CRole::setIndirectSuperRoleLinker(CSortedNegLinker<CRole *> *subRoleList) {
662 indirectSuperRoles = subRoleList;
663 return this;
664 }
665
666 CRole *CRole::addIndirectSuperRoleLinker(CSortedNegLinker<CRole *> *subRoleLinker) {
667 if (indirectSuperRoles) {
668 indirectSuperRoles = indirectSuperRoles->insertSortedNextSorted(subRoleLinker);
669 } else {
670 indirectSuperRoles = subRoleLinker;
671 }
672 return this;
673 }
674
675 CSortedNegLinker<CRole *> *CRole::getIndirectSuperRoleList() {
676 return indirectSuperRoles;
677 }
678
679
680 bool CRole::hasIndirectSuperRole(CRole* role) {
681 CSortedNegLinker<CRole *> *superRoleIt = indirectSuperRoles;
682 while (superRoleIt) {
683 CRole *superRole = superRoleIt->getData();
684 if (superRole == role) {
685 return true;
686 }
687 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
688 }
689 return false;
690 }
691
692
693 bool CRole::hasIndirectSuperRoleTag(qint64 tag) {
694 CSortedNegLinker<CRole *> *superRoleIt = indirectSuperRoles;
695 while (superRoleIt) {
696 CRole *superRole = superRoleIt->getData();
697 qint64 superRoleTag = superRole->getRoleTag();
698 if (tag == superRoleTag) {
699 return true;
700 } else if (superRoleTag > tag) {
701 return false;
702 }
703 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
704 }
705 return false;
706 }
707
708
709
710 bool CRole::hasIndirectSuperRoleTag(qint64 tag, bool negated) {
711 CSortedNegLinker<CRole *> *superRoleIt = indirectSuperRoles;
712 while (superRoleIt) {
713 CRole *superRole = superRoleIt->getData();
714 qint64 superRoleTag = superRole->getRoleTag();
715 if (tag == superRoleTag && superRoleIt->isNegated() == negated) {
716 return true;
717 } else if (superRoleTag > tag) {
718 return false;
719 }
720 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
721 }
722 return false;
723 }
724
725
726
727
728 bool CRole::operator<=(const CRole &role) {
729 if (mTag < role.mTag) {
730 return true;
731 } else if (mTag > role.mTag) {
732 return false;
733 } else {
734 return getTerminologyTag() <= role.getTerminologyTag();
735 }
736 }
737
738 bool CRole::operator==(const CRole &role) {
739 return mTag == role.mTag && tax == role.tax;
740 }
741
742
743 bool CRole::hasPropertyName() {
744 return hasName();
745 }
746
747 CRole *CRole::setPropertyNameLinker(CLinker<CName *> *propertyNameLinker) {
748 setNameLinker(propertyNameLinker);
749 return this;
750 }
751
752 CRole *CRole::addPropertyNameLinker(CLinker<CName *> *propertyNameLinker) {
753 addNameLinker(propertyNameLinker);
754 return this;
755 }
756
757 CLinker<CName *> *CRole::getPropertyNameLinker() {
758 return getNameLinker();
759 }
760
761
762 bool CRole::hasRoleChainSubSharing() {
763 return mRoleChainSubSharingLinker != nullptr;
764 }
765
766 CRole *CRole::addRoleChainSubSharingLinker(CXLinker<CRoleChain*>* roleChainLinker) {
767 if (roleChainLinker) {
768 if (!mRoleChainSubSharingLinker) {
769 mRoleChainSubSharingLinker = roleChainLinker;
770 } else {
771 mRoleChainSubSharingLinker = roleChainLinker->append(mRoleChainSubSharingLinker);
772 }
773 }
774 return this;
775 }
776
777 CXLinker<CRoleChain*>* CRole::getRoleChainSubSharingLinker() {
778 return mRoleChainSubSharingLinker;
779 }
780
781 bool CRole::hasRoleChainSubSharingLinker(CRoleChain* roleChain) {
782 CXLinker<CRoleChain*>* roleChainIt = mRoleChainSubSharingLinker;
783 while (roleChainIt) {
784 if (roleChainIt->getData() == roleChain) {
785 return true;
786 }
787 roleChainIt = roleChainIt->getNext();
788 }
789 return false;
790 }
791
792
793 bool CRole::hasRoleChainSuperSharing() {
794 return mRoleChainSuperSharingLinker != nullptr;
795 }
796
797 CRole *CRole::addRoleChainSuperSharingLinker(CXLinker<CRoleChain*>* roleChainLinker) {
798 if (roleChainLinker) {
799 if (!mRoleChainSuperSharingLinker) {
800 mRoleChainSuperSharingLinker = roleChainLinker;
801 } else {
802 mRoleChainSuperSharingLinker = roleChainLinker->append(mRoleChainSuperSharingLinker);
803 }
804 }
805 return this;
806 }
807
808 CXLinker<CRoleChain*>* CRole::getRoleChainSuperSharingLinker() {
809 return mRoleChainSuperSharingLinker;
810 }
811
812 bool CRole::hasRoleChainSuperSharingLinker(CRoleChain* roleChain) {
813 CXLinker<CRoleChain*>* roleChainIt = mRoleChainSuperSharingLinker;
814 while (roleChainIt) {
815 if (roleChainIt->getData() == roleChain) {
816 return true;
817 }
818 roleChainIt = roleChainIt->getNext();
819 }
820 return false;
821 }
822
823
824
825 }; // end namespace Ontology
826
827 }; // end namespace Reasoner
828
829 }; // end namespace Konclude