Debian Codegraph @

Source/Reasoner/Preprocess/CSubroleTransformationPreProcess.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 "CSubroleTransformationPreProcess.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Preprocess {
29
30
31 CSubroleTransformationPreProcess::CSubroleTransformationPreProcess() {
32 }
33
34
35 CSubroleTransformationPreProcess::~CSubroleTransformationPreProcess() {
36 }
37
38
39 CConcreteOntology *CSubroleTransformationPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
40 mOntology = ontology;
41 if (ontology) {
42 mTBox = ontology->getDataBoxes()->getTBox();
43 mABox = ontology->getDataBoxes()->getABox();
44 mRBox = ontology->getDataBoxes()->getRBox();
45 mMBox = ontology->getDataBoxes()->getMBox();
46
47
48
49 mRolesVector = mRBox->getRoleVector();
50 mConceptVector = mTBox->getConceptVector();
51 mIndiVec = mABox->getIndividualVector();
52
53 mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
54
55 mTopObjectRole = nullptr;
56 mBottomObjectRole = nullptr;
57
58 mTopDataRole = nullptr;
59 mBottomDataRole = nullptr;
60
61 QSet<CRole*> mProcessedRoleSet;
62 QSet<cint64> locRoleTagSet;
63 QList<cint64> subRoleUpdateTagList;
64
65 COntologyBuildConstructFlags* construcFlags = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags();
66 bool topObjectRuleUsed = construcFlags->isTopObjectRoleUsed();
67 bool bottomObjectRuleUsed = construcFlags->isBottomObjectRoleUsed();
68
69
70 bool confForceInverseRoleCreation = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Preprocessing.ForceInverseRoleCreation",true);
71 bool confComplexQueryingSupport = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Querying.ComplexQueryingSupport",true);
72
73
74 if (topObjectRuleUsed || confComplexQueryingSupport) {
75 mRoleChainVector = mRBox->getRoleChainVector();
76 makeUniversalSuperRole();
77 }
78 if (bottomObjectRuleUsed) {
79 makeBottomObjectRoleDomain();
80 }
81
82 bool topDataRuleUsed = construcFlags->isTopDataRoleUsed();
83 bool bottomDataRuleUsed = construcFlags->isBottomDataRoleUsed();
84
85 if (topDataRuleUsed) {
86 makeDataSuperRole();
87 }
88 if (bottomDataRuleUsed) {
89 makeBottomDataRoleDomain();
90 }
91
92
93 CBUILDHASH<CRole*, CObjectPropertyTermExpression*>* roleObjPropTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
94 CBUILDHASH<CObjectPropertyTermExpression*, CRole*>* objPropTermRoleHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash();
95 CBUILDLIST<CBuildExpression*>* expressionBuildContainerList = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getExpressionBuildListContainer();
96 CBUILDHASH<CExpressionHasher, CBuildExpression*>* expressionBuildHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getStructuralExpressionBuildHash();
97
98
99 qint64 itemCounts = mRolesVector->getItemCount();
100 for (qint64 i = 0; i < itemCounts; ++i) {
101 CRole *role = mRolesVector->getLocalData(i);
102 if (role) {
103
104 if (!role->getInverseRole() && !role->isDataRole()) {
105 for (CSortedNegLinker<CRole*>* inverseEquivalentRolesIt = role->getInverseEquivalentRoleList(); inverseEquivalentRolesIt && !role->getInverseRole(); inverseEquivalentRolesIt = inverseEquivalentRolesIt->getNext()) {
106 if (inverseEquivalentRolesIt->isNegated()) {
107 role->setInverseRole(inverseEquivalentRolesIt->getData());
108 }
109 }
110 }
111
112 if ((confForceInverseRoleCreation || confComplexQueryingSupport) && !role->hasInverseRoles()) {
113 CRole* inverseRole = CObjectAllocator< CRole >::allocateAndConstruct(mMemMan);
114
115 inverseRole->initRole();
116 inverseRole->setInverseRole(role);
117 inverseRole->setDataRole(role->isDataRole());
118 cint64 inverseRoleTag = mRolesVector->getItemCount();
119 inverseRole->setRoleTag(inverseRoleTag);
120 inverseRole->setRoleComplexity(role->getRoleComplexity());
121 mRolesVector->setData(inverseRole->getRoleTag(), inverseRole);
122
123
124 CSortedNegLinker<CRole*>* invRoleLinker1 = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
125 invRoleLinker1->init(role, true);
126 inverseRole->addSuperRoleLinker(invRoleLinker1);
127 CSortedNegLinker<CRole*>* invRoleLinker2 = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
128 invRoleLinker2->init(inverseRole, true);
129 role->addSuperRoleLinker(invRoleLinker2);
130 role->setInverseRole(inverseRole);
131
132
133 CSortedNegLinker<CRole*>* invEqRoleLinker1 = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
134 invEqRoleLinker1->init(role, true);
135 inverseRole->addEquivalentRoleLinker(invEqRoleLinker1);
136 CSortedNegLinker<CRole*>* invEqRoleLinker2 = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
137 invEqRoleLinker2->init(inverseRole, true);
138 role->addEquivalentRoleLinker(invEqRoleLinker2);
139
140
141 if (mTopObjectRole && (topObjectRuleUsed || confComplexQueryingSupport) && !role->isDataRole()) {
142 CSortedNegLinker<CRole*>* invUnivRoleSuperLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
143 invUnivRoleSuperLinker->init(mTopObjectRole, true);
144 inverseRole->addSuperRoleLinker(invUnivRoleSuperLinker);
145 }
146
147 if (!role->isDataRole()) {
148 CObjectPropertyTermExpression* buildExpression = roleObjPropTermHash->value(role);
149 CInverseObjectPropertyOfExpression* invRoleExpression = new CInverseObjectPropertyOfExpression(buildExpression);
150 expressionBuildHash->insert(CExpressionHasher(invRoleExpression), invRoleExpression);
151 expressionBuildContainerList->append(invRoleExpression);
152 roleObjPropTermHash->insert(role, invRoleExpression);
153 objPropTermRoleHash->insert(invRoleExpression, role);
154 }
155 }
156 }
157 }
158
159
160 itemCounts = mRolesVector->getItemCount();
161 for (qint64 i = 0; i < itemCounts; ++i) {
162 CRole *role = mRolesVector->getLocalData(i);
163 if (role) {
164 locRoleTagSet.insert(role->getRoleTag());
165 subRoleUpdateTagList.append(role->getRoleTag());
166 if (!mProcessedRoleSet.contains(role)) {
167 // update all direct super roles
168
169 QSet< QPair<CRole*,bool> > inEqRoleSet;
170 collectInverseEquivalentRoles(role,false,&inEqRoleSet);
171
172 for (QSet< QPair<CRole*,bool> >::const_iterator it = inEqRoleSet.constBegin(), itEnd = inEqRoleSet.constEnd(); it != itEnd; ++it) {
173 QPair<CRole*,bool> roleNegPair(*it);
174 CRole* upRole = roleNegPair.first;
175 bool upNeg = roleNegPair.second;
176 if (!mProcessedRoleSet.contains(upRole)) {
177 mProcessedRoleSet.insert(upRole);
178 updateDirectSuperRoles(upRole,upNeg,&inEqRoleSet);
179 }
180 }
181 }
182
183 }
184 }
185
186
187
188 QHash<qint64,qint64> roleTagSubRoleTagHash;
189
190 for (qint64 i = 0; i < itemCounts; ++i) {
191 CRole *role = mRolesVector->getLocalData(i);
192 if (role) {
193 cint64 roleTag = role->getRoleTag();
194 CSortedNegLinker<CRole*>* superRoleLinkerIt = role->getSuperRoleList();
195 while (superRoleLinkerIt) {
196 CRole* superRole = superRoleLinkerIt->getData();
197 cint64 superRoleTag = superRole->getRoleTag();
198 roleTagSubRoleTagHash.insertMulti(superRoleTag,roleTag);
199 superRoleLinkerIt = superRoleLinkerIt->getNext();
200 }
201 }
202 }
203
204 FOREACHIT (cint64 locRoleTag, locRoleTagSet) {
205 FOREACHIT (cint64 subRoleTag, roleTagSubRoleTagHash.values(locRoleTag)) {
206 if (!locRoleTagSet.contains(subRoleTag)) {
207 locRoleTagSet.insert(subRoleTag);
208 subRoleUpdateTagList.append(subRoleTag);
209 }
210 }
211 }
212
213 while (!subRoleUpdateTagList.isEmpty()) {
214 cint64 updateTag = subRoleUpdateTagList.takeFirst();
215 CRole *role = mRolesVector->getData(updateTag);
216 role = getLocalizedRole(role);
217
218 if (role) {
219 // update indirect super role list
220 QSet< QPair<CRole*,bool> > singleSuperRoleAddSet;
221 singleSuperRoleAddSet.insert(QPair<CRole*,bool>(role,false));
222 CSortedNegLinker<CRole *> *superRoleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
223 superRoleLinker->init(role,false);
224 role->setIndirectSuperRoleLinker(superRoleLinker);
225
226 addIndirectSuperRoles(false,role,role->getSuperRoleList(),&singleSuperRoleAddSet);
227
228 FOREACHIT (cint64 subRoleTag, roleTagSubRoleTagHash.values(updateTag)) {
229 if (!locRoleTagSet.contains(subRoleTag)) {
230 locRoleTagSet.insert(subRoleTag);
231 subRoleUpdateTagList.append(subRoleTag);
232 }
233 }
234
235 }
236 }
237
238 for (qint64 i = 0; i < itemCounts; ++i) {
239 CRole *role = mRolesVector->getLocalData(i);
240 if (role) {
241 if (role->getRoleChainSuperSharingLinker() != nullptr) {
242 role->setRoleComplexity(true);
243 // all super roles must be complex, too
244
245 CSortedNegLinker<CRole*>* superRoleLinkerIt = role->getIndirectSuperRoleList();
246 while (superRoleLinkerIt) {
247 CRole* superRole = superRoleLinkerIt->getData();
248 if (!superRole->isComplexRole()) {
249 superRole = getLocalizedRole(superRole);
250 superRole->setRoleComplexity(true);
251 }
252 superRoleLinkerIt = superRoleLinkerIt->getNext();
253 }
254 }
255 }
256 }
257
258 if (topObjectRuleUsed && mABox->getIndividualCount() > 0 && hasUniversalRolePropagation()) {
259 makeUniversalConnectionIndividual();
260 }
261 }
262
263 cint64 conCount = mConceptVector->getItemCount();
264 mLastConceptId = conCount;
265
266
267 return ontology;
268 }
269
270
271
272
273 CConcreteOntology* CSubroleTransformationPreProcess::continuePreprocessing() {
274 cint64 conCount = mConceptVector->getItemCount();
275
276 if (!mABox->hasUniversalConnectionIndividual()) {
277 for (qint64 i = mLastConceptId; i < conCount && !mABox->hasUniversalConnectionIndividual(); ++i) {
278 CConcept *concept = mConceptVector->getLocalData(i);
279 if (concept) {
280 cint64 opCode = concept->getOperatorCode();
281 if (opCode == CCALL || opCode == CCSOME || opCode == CCIMPLALL || opCode == CCBRANCHALL || opCode == CCVARBINDALL || opCode == CCPBINDALL || opCode == CCVARPBACKALL) {
282 CRole* role = concept->getRole();
283 if (role->getRoleTag() == 1) {
284 makeUniversalConnectionIndividual();
285 }
286 }
287 }
288 }
289 }
290 mLastConceptId = conCount;
291
292 return mOntology;
293 }
294
295
296
297
298 void CSubroleTransformationPreProcess::makeUniversalConnectionIndividual() {
299 cint64 univConnIndiID = 0;
300 CIndividual* universalConnIndi = nullptr;
301 CConcept* universalConnNominalValueCon = nullptr;
302 CConcept* universalConnNominalCon = nullptr;
303 if (!mABox->hasUniversalConnectionIndividual()) {
304 univConnIndiID = mABox->getNextIndividualId();
305 mABox->setUniversalConnectionIndividualID(univConnIndiID);
306 mABox->setHasUniversalConnectionIndividual(true);
307 universalConnIndi = CObjectAllocator< CIndividual >::allocateAndConstruct(mMemMan);
308 universalConnIndi->initIndividual(univConnIndiID);
309 universalConnIndi->setFakeIndividual(true);
310 mIndiVec->setData(univConnIndiID, universalConnIndi);
311
312 cint64 valueConTag = mTBox->getNextConceptID();
313 universalConnNominalValueCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
314 universalConnNominalValueCon->initConcept();
315 universalConnNominalValueCon->setConceptTag(valueConTag);
316 universalConnNominalValueCon->setOperatorCode(CCVALUE);
317 universalConnNominalValueCon->setNominalIndividual(universalConnIndi);
318 universalConnNominalValueCon->setRole(mRolesVector->getData(1));
319 mConceptVector->setData(valueConTag,universalConnNominalValueCon);
320 mTBox->setUniversalConnectionNominalValueConcept(universalConnNominalValueCon);
321
322
323 cint64 nominalConTag = mTBox->getNextConceptID();
324 universalConnNominalCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
325 universalConnNominalCon->initConcept();
326 universalConnNominalCon->setConceptTag(nominalConTag);
327 universalConnNominalCon->setOperatorCode(CCNOMINAL);
328 universalConnNominalCon->setNominalIndividual(universalConnIndi);
329 mConceptVector->setData(nominalConTag,universalConnNominalCon);
330 universalConnIndi->setIndividualNominalConcept(universalConnNominalCon);
331
332 }
333 }
334
335
336 void CSubroleTransformationPreProcess::makeBottomObjectRoleDomain() {
337 mBottomObjectRole = mRolesVector->getData(mRBox->getBottomObjectRoleIndex());
338 makeBottomRoleDomain(mBottomObjectRole);
339 }
340
341
342 void CSubroleTransformationPreProcess::makeBottomDataRoleDomain() {
343 mBottomDataRole = mRolesVector->getData(mRBox->getBottomDataRoleIndex());
344 makeBottomRoleDomain(mBottomDataRole);
345 }
346
347
348 void CSubroleTransformationPreProcess::makeBottomRoleDomain(CRole* role) {
349 bool foundBottom = false;
350 for (CSortedNegLinker<CConcept*>* domainConIt = role->getDomainConceptList(); !foundBottom && domainConIt; domainConIt = domainConIt->getNext()) {
351 CConcept* domainConcept = domainConIt->getData();
352 bool domainConNegation = domainConIt->isNegated();
353 if (domainConNegation && domainConcept->getOperatorCode() == CCTOP) {
354 foundBottom = true;
355 } else if (!domainConNegation && domainConcept->getOperatorCode() == CCBOTTOM) {
356 foundBottom = true;
357 }
358 }
359 if (!foundBottom) {
360 role = getLocalizedRole(role);
361 CSortedNegLinker<CConcept*>* domainConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
362 domainConLinker->init(mTBox->getTopConcept(),true);
363 role->addDomainConceptLinker(domainConLinker);
364 }
365 }
366
367
368 void CSubroleTransformationPreProcess::makeUniversalSuperRole() {
369 mOntology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->setComplexRoleUsed();
370 bool topRoleLocalized = false;
371 mTopObjectRole = mRolesVector->getData(mRBox->getTopObjectRoleIndex(), &topRoleLocalized);
372 if (!mTopObjectRole->isTransitive()) {
373 if (!topRoleLocalized) {
374 topRoleLocalized = true;
375 mTopObjectRole = getLocalizedRole(mTopObjectRole);
376 }
377 mTopObjectRole->setTransitive(true);
378 cint64 roleChainCount = mRoleChainVector->getItemCount();
379 CRoleChain* roleChain = CObjectAllocator< CRoleChain >::allocateAndConstruct(mMemMan);
380 roleChain->initRoleChain();
381 CXLinker<CRole*>* roleLinker1 = CObjectAllocator< CXLinker<CRole*> >::allocateAndConstruct(mMemMan);
382 CXLinker<CRole*>* roleLinker2 = CObjectAllocator< CXLinker<CRole*> >::allocateAndConstruct(mMemMan);
383 roleLinker1->initLinker(mTopObjectRole);
384 roleLinker2->initLinker(mTopObjectRole);
385 roleChain->appendRoleChainLinker(roleLinker1);
386 roleChain->appendRoleChainLinker(roleLinker2);
387 roleChain->initTag(roleChainCount);
388 mRoleChainVector->setData(roleChainCount,roleChain);
389
390 CXLinker<CRoleChain*>* superRoleChainLinker = CObjectAllocator< CXLinker<CRoleChain*> >::allocateAndConstruct(mMemMan);
391 superRoleChainLinker->initLinker(roleChain);
392 mTopObjectRole->addRoleChainSuperSharingLinker(superRoleChainLinker);
393 CXLinker<CRoleChain*>* subRoleChainLinker = CObjectAllocator< CXLinker<CRoleChain*> >::allocateAndConstruct(mMemMan);
394 subRoleChainLinker->initLinker(roleChain);
395 mTopObjectRole->addRoleChainSubSharingLinker(subRoleChainLinker);
396 }
397 if (!mTopObjectRole->isSymmetric()) {
398 if (!topRoleLocalized) {
399 topRoleLocalized = true;
400 mTopObjectRole = getLocalizedRole(mRolesVector->getData(mRBox->getTopObjectRoleIndex()));
401 }
402 mTopObjectRole->setSymmetric(true);
403
404 CSortedNegLinker<CRole*>* roleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
405 roleLinker->init(mTopObjectRole,true);
406 mTopObjectRole->addInverseRoleLinker(roleLinker);
407 }
408 cint64 roleCount = mRolesVector->getItemCount();
409 for (cint64 roleIdx = 1; roleIdx < roleCount; ++roleIdx) {
410 CRole* role = mRolesVector->getData(roleIdx);
411 if (role && role->isObjectRole() && !role->hasSuperRoleTag(mTopObjectRole->getRoleTag())) {
412 role = getLocalizedRole(role);
413
414 CSortedNegLinker<CRole*>* roleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
415 roleLinker->init(mTopObjectRole,true);
416 role->addSuperRoleLinker(roleLinker);
417 }
418 }
419 // make reflexive -> add \exists u.SELF to TOP
420 bool topConLocal = false;
421 CConcept* topConcept = mConceptVector->getData(1,&topConLocal);
422 bool hasTopExistsUniversalSelf = false;
423 bool renewTopExistsUniversalSelf = false;
424 CConcept* existsUniversalSelfConcept = nullptr;
425 for (CSortedNegLinker<CConcept*>* opLinker = topConcept->getOperandList(); !hasTopExistsUniversalSelf && opLinker; opLinker = opLinker->getNext()) {
426 if (!opLinker->isNegated()) {
427 CConcept* opConcept = opLinker->getData();
428 if (opConcept->getOperatorCode() == CCSELF && opConcept->getRole()->getRoleTag() == mTopObjectRole->getRoleTag()) {
429 hasTopExistsUniversalSelf = true;
430 existsUniversalSelfConcept = opConcept;
431 if (opConcept->getRole() != mTopObjectRole) {
432 renewTopExistsUniversalSelf = true;
433 }
434 }
435 }
436 }
437 if (!hasTopExistsUniversalSelf) {
438 if (!topConLocal) {
439 topConcept = CConceptRoleIndividualLocator::getLocatedConcept(topConcept, mOntology);
440 }
441 CConcept* univSelfCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
442 cint64 conCount = mTBox->getNextConceptID();
443 univSelfCon->initConcept();
444 univSelfCon->setConceptTag(conCount);
445 univSelfCon->setRole(mTopObjectRole);
446 univSelfCon->setOperatorCode(CCSELF);
447 mConceptVector->setData(conCount,univSelfCon);
448
449 CSortedNegLinker<CConcept*>* topOpLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
450 topOpLinker->init(univSelfCon,false);
451 topConcept->addOperandLinker(topOpLinker);
452 topConcept->incOperandCount(1);
453 } else if (renewTopExistsUniversalSelf) {
454 if (!topConLocal) {
455 topConcept = CConceptRoleIndividualLocator::getLocatedConcept(topConcept, mOntology);
456 }
457 CConcept* univSelfCon = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
458 cint64 conCount = mTBox->getNextConceptID();
459 univSelfCon->initConcept();
460 univSelfCon->setConceptTag(conCount);
461 univSelfCon->setRole(mTopObjectRole);
462 univSelfCon->setOperatorCode(CCSELF);
463 mConceptVector->setData(conCount, univSelfCon);
464 bool replaced = false;
465
466 for (CSortedNegLinker<CConcept*>* opLinker = topConcept->getOperandList(); !replaced && opLinker; opLinker = opLinker->getNext()) {
467 if (opLinker->getData() == existsUniversalSelfConcept) {
468 opLinker->setData(univSelfCon);
469 replaced = true;
470 }
471 }
472 }
473
474 }
475
476
477
478
479
480 void CSubroleTransformationPreProcess::makeDataSuperRole() {
481 mTopDataRole = getLocalizedRole(mRolesVector->getData(mRBox->getTopDataRoleIndex()));
482 cint64 roleCount = mRolesVector->getItemCount();
483 for (cint64 roleIdx = 0; roleIdx < roleCount; ++roleIdx) {
484 CRole* role = mRolesVector->getData(roleIdx);
485 if (role && role->isDataRole() && !role->hasSuperRoleTag(mTopDataRole->getRoleTag())) {
486 role = getLocalizedRole(role);
487
488 CSortedNegLinker<CRole*>* roleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
489 roleLinker->init(mTopDataRole,true);
490 role->addSuperRoleLinker(roleLinker);
491 }
492 }
493 }
494
495
496
497 CIndividual* CSubroleTransformationPreProcess::getLocalizedIndividual(CIndividual* individual) {
498 cint64 indiID = individual->getIndividualID();
499 if (!mIndiVec->hasLocalData(indiID)) {
500 individual = CConceptRoleIndividualLocator::getLocatedIndividual(mIndiVec->getLocalData(indiID),mOntology);
501 } else {
502 individual = mIndiVec->getLocalData(indiID);
503 }
504 return individual;
505 }
506
507 CRole* CSubroleTransformationPreProcess::getLocalizedRole(CRole* role) {
508 cint64 roleTag = role->getRoleTag();
509 if (!mRolesVector->hasLocalData(roleTag)) {
510 role = CConceptRoleIndividualLocator::getLocatedRole(role,mOntology);
511 } else {
512 role = mRolesVector->getLocalData(roleTag);
513 }
514 return role;
515 }
516
517
518
519 CSubroleTransformationPreProcess* CSubroleTransformationPreProcess::updateDirectSuperRoles(CRole* role, bool negated, QSet< QPair<CRole*,bool> >* roleSet) {
520 role = getLocalizedRole(role);
521 for (QSet< QPair<CRole*,bool> >::const_iterator it = roleSet->constBegin(), itEnd = roleSet->constEnd(); it != itEnd; ++it) {
522 QPair<CRole*,bool> roleNegPair(*it);
523 CRole* upRole = roleNegPair.first;
524 bool upNeg = roleNegPair.second^negated;
525 cint64 upRoleTag = upRole->getRoleTag();
526 if (upRole != role || upNeg) {
527 if (!role->hasSuperRoleTag(upRoleTag,upNeg)) {
528 CSortedNegLinker<CRole*>* superRoleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
529 superRoleLinker->init(upRole,upNeg);
530 role->addSuperRoleLinker(superRoleLinker);
531 }
532 }
533 }
534 return this;
535 }
536
537
538
539 CSubroleTransformationPreProcess* CSubroleTransformationPreProcess::collectInverseEquivalentRoles(CRole* role, bool negated, QSet< QPair<CRole*,bool> >* roleSet) {
540 if (!roleSet->contains(QPair<CRole*,bool>(role,negated))) {
541 roleSet->insert(QPair<CRole*,bool>(role,negated));
542 CSortedNegLinker<CRole*>* inEqRoleLinker = role->getInverseEquivalentRoleList();
543 while (inEqRoleLinker) {
544 CRole* inEqRole = inEqRoleLinker->getData();
545 inEqRole = mRolesVector->getData(inEqRole->getRoleTag());
546 bool inEqRoleNeg = inEqRoleLinker->isNegated();
547 collectInverseEquivalentRoles(inEqRole,inEqRoleNeg^negated,roleSet);
548 inEqRoleLinker = inEqRoleLinker->getNext();
549 }
550 }
551 return this;
552 }
553
554
555
556
557 bool CSubroleTransformationPreProcess::hasUniversalRolePropagation() {
558 QSet<CRole*> topSuperRoleSet;
559 topSuperRoleSet.insert(mTopObjectRole);
560 for (CSortedNegLinker<CRole*>* topSuperRoleIt = mTopObjectRole->getIndirectSuperRoleList(); topSuperRoleIt; topSuperRoleIt = topSuperRoleIt->getNext()) {
561 CRole* topSuperRole = topSuperRoleIt->getData();
562 topSuperRoleSet.insert(topSuperRole);
563 }
564 cint64 conCount = mConceptVector->getItemCount();
565 for (cint64 conIdx = 0; conIdx < conCount; ++conIdx) {
566 CConcept* concept = mConceptVector->getData(conIdx);
567 if (concept && concept->getOperatorCode() != CCSELF) {
568 CRole* role = concept->getRole();
569 if (role && topSuperRoleSet.contains(role)) {
570 return true;
571 }
572 }
573 }
574 return false;
575 }
576
577
578 void CSubroleTransformationPreProcess::addIndirectSuperRoles(bool inverse, CRole *modifingSubRole, CSortedNegLinker<CRole *> *superRoleLinker, QSet< QPair<CRole*,bool> > *singleSuperRoleAddSet) {
579
580 CSortedNegLinker<CRole *> *superRoleIt = superRoleLinker;
581 while (superRoleIt) {
582 CRole *superRole = superRoleIt->getData();
583 superRole = mRolesVector->getData(superRole->getRoleTag());
584 bool inversed = superRoleIt->isNegated()^inverse;
585
586 if (!singleSuperRoleAddSet->contains(QPair<CRole*,bool>(superRole,inversed))) {
587 singleSuperRoleAddSet->insert(QPair<CRole*,bool>(superRole,inversed));
588
589 CSortedNegLinker<CRole *> *nextSuperRoleLinker = CObjectAllocator< CSortedNegLinker<CRole*> >::allocateAndConstruct(mMemMan);
590 nextSuperRoleLinker->init(superRole,inversed);
591 modifingSubRole->addIndirectSuperRoleLinker(nextSuperRoleLinker);
592
593 addIndirectSuperRoles(inversed,modifingSubRole,superRole->getSuperRoleList(),singleSuperRoleAddSet);
594 }
595
596 superRoleIt = (CSortedNegLinker<CRole *> *)superRoleIt->getNext();
597 }
598 }
599
600
601
602
603 }; // end namespace Preprocess
604
605 }; // end namespace Reasoner
606
607 }; // end namespace Konclude