| 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 |