/*
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
*
* This file is part of the reasoning system Konclude.
* For details and support, see .
*
* Konclude is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Lesser General Public
* License (LGPLv3) as published by the Free Software Foundation.
*
* Konclude is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU (Lesser) General Public License for more details.
*
* You should have received a copy of the GNU (Lesser) General Public
* License along with Konclude. If not, see .
*
*/
#include "CRoleChainAutomataTransformationPreProcess.h"
namespace Konclude {
namespace Reasoner {
namespace Preprocess {
CRoleChainAutomataTransformationPreProcess::CRoleChainAutomataTransformationPreProcess() {
mConfSaveTransitiveTransitions = true;
mOntology = nullptr;
mLastConceptForallId = 0;
mLastConceptValueId = 0;
}
CRoleChainAutomataTransformationPreProcess::~CRoleChainAutomataTransformationPreProcess() {
}
CConcreteOntology *CRoleChainAutomataTransformationPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
mOntology = nullptr;
mLastConceptForallId = 0;
mLastConceptValueId = 0;
bool complexRoleConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isComplexRoleUsed();
if (complexRoleConstructsUsed) {
mOntology = ontology;
CTBox* tbox = ontology->getDataBoxes()->getTBox();
CABox *abox = ontology->getDataBoxes()->getABox();
CRBox *rbox = ontology->getDataBoxes()->getRBox();
CMBox* mBox = ontology->getDataBoxes()->getMBox();
mStatAutomateTransitionConceptCount = 0;
mStatAutomateStateConceptCount = 0;
mStatAutomateTransformedConceptCount = 0;
mStatAutomateTransitiveSavedCount = 0;
mStatCreatedDomainPropagationCount = 0;
mStatCreatedRangePropagationCount = 0;
mStatPropagatedAlreadyInDomainRangeCount = 0;
mStatPropagationAlreadyInDomainRangeCount = 0;
mStatDomainPropagationCount = 0;
mStatRangePropagationCount = 0;
mRoleVec = rbox->getRoleVector();
mConVec = tbox->getConceptVector();
mNextConceptTag = tbox->getNextConceptID();
mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
mRoleObjPropTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
mObjPropTermRoleHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash();
mExpressionBuildContainerList = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getExpressionBuildListContainer();
mInverseObjectPropertyHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getInverseObjectPropertyHash();
mExpressionBuildHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getStructuralExpressionBuildHash();
collectSubRoleChains();
createMissingInverseChainedRoles();
createInverseRoleChainLinkers();
transformVALUERestrictions();
createDomainRangePropagations();
createRecursiveTraversalData();
transformFORALLPropagations();
if (mStatAutomateTransformedConceptCount > 0) {
LOG(INFO,"::Konclude::Reasoner::Preprocess::RoleChainAutomataTransformation",logTr("Transformed %1 concepts to automate.").arg(mStatAutomateTransformedConceptCount),this);
LOG(INFO,"::Konclude::Reasoner::Preprocess::RoleChainAutomataTransformation",logTr("Generated %1 automate state and %2 automate transaction concepts.").arg(mStatAutomateStateConceptCount).arg(mStatAutomateTransitionConceptCount),this);
}
}
return ontology;
}
CConcreteOntology* CRoleChainAutomataTransformationPreProcess::continuePreprocessing() {
if (mOntology) {
mNextConceptTag = mOntology->getTBox()->getNextConceptID();
transformVALUERestrictions();
transformFORALLPropagations();
}
return mOntology;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::transformFORALLPropagations() {
cint64 conCount = mConVec->getItemCount();
for (qint64 i = mLastConceptForallId; i < conCount; ++i) {
CConcept *concept = mConVec->getLocalData(i);
if (concept) {
cint64 opCode = concept->getOperatorCode();
if (opCode == CCALL || opCode == CCSOME || opCode == CCIMPLALL || opCode == CCBRANCHALL || opCode == CCVARBINDALL || opCode == CCPBINDALL || opCode == CCVARPBACKALL) {
CRole* role = concept->getRole();
role = mRoleVec->getData(role->getRoleTag());
if (role->isComplexRole()) {
concept = CConceptRoleIndividualLocator::getLocatedConcept(concept, mOntology);
// translate into concept role automate
++mStatAutomateTransformedConceptCount;
convertAutomatConcept(concept);
}
}
}
}
mLastConceptForallId = conCount;
return this;
}
CConcreteOntology* CRoleChainAutomataTransformationPreProcess::preprocess(CConcreteOntology *ontology, QSet* transformConceptSet, CPreProcessContext* context) {
mOntology = ontology;
CTBox* tbox = ontology->getDataBoxes()->getTBox();
CABox *abox = ontology->getDataBoxes()->getABox();
CRBox *rbox = ontology->getDataBoxes()->getRBox();
CMBox* mBox = ontology->getDataBoxes()->getMBox();
mStatAutomateTransitionConceptCount = 0;
mStatAutomateStateConceptCount = 0;
mStatAutomateTransformedConceptCount = 0;
mStatAutomateTransitiveSavedCount = 0;
mStatCreatedDomainPropagationCount = 0;
mStatCreatedRangePropagationCount = 0;
mStatPropagatedAlreadyInDomainRangeCount = 0;
mStatPropagationAlreadyInDomainRangeCount = 0;
mStatDomainPropagationCount = 0;
mStatRangePropagationCount = 0;
mRoleVec = rbox->getRoleVector();
mConVec = tbox->getConceptVector();
mNextConceptTag = tbox->getNextConceptID();
mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager();
mRoleObjPropTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
mObjPropTermRoleHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash();
mExpressionBuildContainerList = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getExpressionBuildListContainer();
mInverseObjectPropertyHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getInverseObjectPropertyHash();
mExpressionBuildHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getStructuralExpressionBuildHash();
collectSubRoleChains();
createRecursiveTraversalData();
for (QSet::const_iterator conIt = transformConceptSet->constBegin(), conItEnd = transformConceptSet->constEnd(); conIt != conItEnd; ++conIt) {
CConcept *concept(*conIt);
if (concept) {
cint64 opCode = concept->getOperatorCode();
if (opCode == CCALL || opCode == CCSOME || opCode == CCIMPLALL || opCode == CCBRANCHALL || opCode == CCVARBINDALL || opCode == CCPBINDALL || opCode == CCVARPBACKALL) {
CRole* role = concept->getRole();
role = mRoleVec->getData(role->getRoleTag());
if (role->isComplexRole()) {
concept = CConceptRoleIndividualLocator::getLocatedConcept(concept,ontology);
// translate into concept role automate
++mStatAutomateTransformedConceptCount;
convertAutomatConcept(concept);
}
}
}
}
return mOntology;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::transformVALUERestrictions() {
cint64 conCount = mConVec->getItemCount();
for (qint64 i = mLastConceptValueId; i < conCount; ++i) {
bool localFlag = false;
//CConcept *concept = mConVec->getData(i, &localFlag);
CConcept *concept = mConVec->getLocalData(i);
if (concept) {
bool transformToExistentialNominal = false;
cint64 opCode = concept->getOperatorCode();
if (opCode == CCVALUE) {
CRole* role = concept->getRole();
role = mRoleVec->getData(role->getRoleTag());
if (role->isComplexRole()) {
transformToExistentialNominal = true;
}
}
if (transformToExistentialNominal) {
//if (!localFlag) {
// concept = CConceptRoleIndividualLocator::getLocatedConcept(concept,mOntology);
//}
CIndividual* nomIndividual = concept->getNominalIndividual();
concept->setOperatorCode(CCSOME);
concept->setNominalIndividual(nullptr);
CConcept* nomIndividualConcept = nomIndividual->getIndividualNominalConcept();
if (!nomIndividualConcept) {
nomIndividualConcept = createNominalConcept(nomIndividual);
}
CSortedNegLinker* opLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
opLinker->init(nomIndividualConcept,false);
concept->setOperandList(opLinker);
}
}
}
mLastConceptValueId = conCount;
return this;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::createDomainRangePropagations() {
QSet domRangePropCocneptSet;
qint64 itemCounts = mRoleVec->getItemCount();
for (qint64 i = 0; i < itemCounts; ++i) {
CRole *role = mRoleVec->getLocalData(i);
if (role && role->isComplexRole()) {
CRole* inverseRole = nullptr;
for (CSortedNegLinker* domainConLinker = role->getDomainConceptList(); domainConLinker; domainConLinker = domainConLinker->getNext()) {
CConcept* domCon = domainConLinker->getData();
bool domConNeg = domainConLinker->isNegated();
if (domConNeg || !domRangePropCocneptSet.contains(domCon)) {
++mStatRangePropagationCount;
if (!inverseRole) {
inverseRole = getInverseRole(role);
}
QList subRoleItemList;
foreach (CRoleSubRoleChainData data, mRoleSubRoleChainDataHash.values(role)) {
subRoleItemList.append(CRoleSubRoleChainDataItem(data));
}
CConcept* propConcept = nullptr;
while (!subRoleItemList.isEmpty()) {
CRoleSubRoleChainData subRoleData = nullptr;
bool allowPropagatedConcept = true;
bool inversedToOrginal = false;
CRoleSubRoleChainDataItem dataItem(subRoleItemList.takeFirst());
subRoleData = dataItem.mChainData;
allowPropagatedConcept = dataItem.mAllowPropagated;
inversedToOrginal = dataItem.mNegated ^ subRoleData.mInverse;
CRoleChain* roleChain = subRoleData.mRoleChain;
CRole* firstSubRole = nullptr;
CRole* lastSubRole = nullptr;
if (inversedToOrginal) {
firstSubRole = getInverseRole(roleChain->getInverseRoleChainLinker()->getData());
lastSubRole = getInverseRole(roleChain->getInverseRoleChainLinker()->getLastListLink()->getData());
} else {
firstSubRole = roleChain->getRoleChainLinker()->getData();
lastSubRole = roleChain->getRoleChainLinker()->getLastListLink()->getData();
}
if (!hasPropagationConcept(domConNeg,domCon,inverseRole,lastSubRole->getIndirectSuperRoleList(),true) && (!allowPropagatedConcept || !hasPropagatedConcept(domConNeg,domCon,firstSubRole->getIndirectSuperRoleList(),true))) {
if (!propConcept) {
propConcept = createTransitionConcept(inverseRole,TTNORMAL);
propConcept->setOperatorCode(CCALL);
appendTransitionOperandConceptLinker(propConcept,createTransitionOperandConceptLinker(domCon,domConNeg));
}
domRangePropCocneptSet.insert(propConcept);
CSortedNegLinker* newConLinker = createTransitionOperandConceptLinker(propConcept,false);
lastSubRole->addRangeConceptLinker(newConLinker);
++mStatCreatedDomainPropagationCount;
foreach (CRoleSubRoleChainData data, mRoleSubRoleChainDataHash.values(lastSubRole)) {
subRoleItemList.append(CRoleSubRoleChainDataItem(data,false));
}
}
}
}
}
for (CSortedNegLinker* rangeConLinker = role->getRangeConceptList(); rangeConLinker; rangeConLinker = rangeConLinker->getNext()) {
CConcept* rangeCon = rangeConLinker->getData();
bool rangeConNeg = rangeConLinker->isNegated();
if (rangeConNeg || !domRangePropCocneptSet.contains(rangeCon)) {
++mStatDomainPropagationCount;
QList subRoleItemList;
foreach (CRoleSubRoleChainData data, mRoleSubRoleChainDataHash.values(role)) {
subRoleItemList.append(CRoleSubRoleChainDataItem(data));
}
CConcept* propConcept = nullptr;
while (!subRoleItemList.isEmpty()) {
CRoleSubRoleChainData subRoleData = nullptr;
bool allowPropagatedConcept = true;
bool inversedToOrginal = false;
CRoleSubRoleChainDataItem dataItem(subRoleItemList.takeFirst());
subRoleData = dataItem.mChainData;
allowPropagatedConcept = dataItem.mAllowPropagated;
inversedToOrginal = dataItem.mNegated ^ subRoleData.mInverse;
CRoleChain* roleChain = subRoleData.mRoleChain;
CRole* firstSubRole = nullptr;
CRole* lastSubRole = nullptr;
if (inversedToOrginal) {
firstSubRole = getInverseRole(roleChain->getInverseRoleChainLinker()->getData());
lastSubRole = getInverseRole(roleChain->getInverseRoleChainLinker()->getLastListLink()->getData());
} else {
firstSubRole = roleChain->getRoleChainLinker()->getData();
lastSubRole = roleChain->getRoleChainLinker()->getLastListLink()->getData();
}
if (!hasPropagationConcept(rangeConNeg,rangeCon,role,firstSubRole->getIndirectSuperRoleList(),false) && (!allowPropagatedConcept || !hasPropagatedConcept(rangeConNeg,rangeCon,lastSubRole->getIndirectSuperRoleList(),false))) {
if (!propConcept) {
propConcept = createTransitionConcept(role,TTNORMAL);
propConcept->setOperatorCode(CCALL);
appendTransitionOperandConceptLinker(propConcept,createTransitionOperandConceptLinker(rangeCon,rangeConNeg));
}
domRangePropCocneptSet.insert(propConcept);
CSortedNegLinker* newConLinker = createTransitionOperandConceptLinker(propConcept,false);
firstSubRole->addDomainConceptLinker(newConLinker);
++mStatCreatedRangePropagationCount;
foreach (CRoleSubRoleChainData data, mRoleSubRoleChainDataHash.values(firstSubRole)) {
subRoleItemList.append(CRoleSubRoleChainDataItem(data,false));
}
}
}
}
}
}
}
return this;
}
bool CRoleChainAutomataTransformationPreProcess::hasPropagatedConcept(bool negated, CConcept* concept, CSortedNegLinker* roleList, bool inverseDomRange) {
for (CSortedNegLinker* roleListLinker = roleList; roleListLinker; roleListLinker = roleListLinker->getNext()) {
CRole* superRole = roleListLinker->getData();
bool superRoleNeg = roleListLinker->isNegated();
bool switchDomainRange = inverseDomRange ^ superRoleNeg;
CSortedNegLinker* conList = superRole->getDomainRangeConceptList(!switchDomainRange);
for (CSortedNegLinker* conListLinker = conList; conListLinker; conListLinker = conListLinker->getNext()) {
CConcept* con = conListLinker->getData();
bool conNeg = conListLinker->isNegated();
cint64 conCode = con->getOperatorCode();
if (con == concept && conNeg == negated) {
++mStatPropagatedAlreadyInDomainRangeCount;
return true;
}
}
}
return false;
}
bool CRoleChainAutomataTransformationPreProcess::hasPropagationConcept(bool negated, CConcept* concept, CRole* role, CSortedNegLinker* roleList, bool inverseDomRange) {
for (CSortedNegLinker* roleListLinker = roleList; roleListLinker; roleListLinker = roleListLinker->getNext()) {
CRole* superRole = roleListLinker->getData();
bool superRoleNeg = roleListLinker->isNegated();
bool switchDomainRange = inverseDomRange ^ superRoleNeg;
CSortedNegLinker* conList = superRole->getDomainRangeConceptList(switchDomainRange);
for (CSortedNegLinker* conListLinker = conList; conListLinker; conListLinker = conListLinker->getNext()) {
CConcept* con = conListLinker->getData();
bool conNeg = conListLinker->isNegated();
if (con->getRole() == role) {
cint64 conCode = con->getOperatorCode();
if ((conCode == CCALL || conCode == CCAQALL || conCode == CCIMPLALL) && !conNeg || conNeg && (conCode == CCSOME)) {
for (CSortedNegLinker* opListLinker = con->getOperandList(); opListLinker; opListLinker = opListLinker->getNext()) {
if (opListLinker->getData() == concept && opListLinker->isNegated()^conNeg == negated) {
++mStatPropagationAlreadyInDomainRangeCount;
return true;
}
}
}
}
}
}
return false;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::convertAutomatConcept(CConcept* concept) {
CSortedNegLinker* opConLinker = concept->getOperandList();
cint64 opCount = concept->getOperandCount();
CRole* role = concept->getRole();
role = mRoleVec->getData(role->getRoleTag());
bool existNegation = false;
if (concept->getOperatorCode() == CCSOME) {
existNegation = true;
}
//if (CIRIName::getRecentIRIName(role->getPropertyNameLinker()) == "#LocativeAttribute") {
// if (CIRIName::getRecentIRIName(concept->getOperandList()->getData()->getClassNameLinker()) == "#Heart") {
// bool bug = true;
// }
//}
// transformation into automat concept
bool implTransisition = false;
TRANSLATIONTYPE transType = TTNORMAL;
cint64 opCode = concept->getOperatorCode();
if (opCode == CCIMPLALL) {
// implication transition is never negated
transType = TTIMPL;
} else if (opCode == CCBRANCHALL) {
transType = TTBRANCH;
} else if (opCode == CCPBINDALL) {
transType = TTPROPBIND;
} else if (opCode == CCVARPBACKALL) {
transType = TTBACKPROP;
} else if (opCode == CCVARBINDALL) {
transType = TTVARBIND;
}
CConcept* generatingConcept = nullptr;
CConcept* beginState = nullptr;
CConcept* propCon = nullptr;
CConcept* endState = nullptr;
if (transType == TTNORMAL) {
concept->setOperatorCode(CCAQCHOOCE);
generatingConcept = createAutomatGeneratingConcept(opConLinker,!existNegation,role);
beginState = createStateConcept(transType);
} else {
beginState = concept;
cint64 opCode = CCAQAND;
if (transType == TTIMPL) {
opCode = CCIMPLAQAND;
} else if (transType == TTBRANCH) {
opCode = CCBRANCHAQAND;
} else if (transType == TTPROPBIND) {
opCode = CCPBINDAQAND;
} else if (transType == TTBACKPROP) {
opCode = CCVARPBACKAQAND;
} else if (transType == TTVARBIND) {
opCode = CCVARBINDAQAND;
}
beginState->setOperatorCode(opCode);
beginState->setRole(nullptr);
}
concept->setOperandList(nullptr);
concept->setOperandCount(0);
propCon = createTransitionConcept(role,transType);
endState = createStateConcept(transType);
CSortedNegLinker* opLinkerIt = opConLinker;
while (opLinkerIt) {
CConcept* opConcept = opLinkerIt->getData();
bool opNegation = opLinkerIt->isNegated() ^ existNegation;
appendTransitionOperandConceptLinker(endState,createTransitionOperandConceptLinker(opConcept,opNegation));
opLinkerIt = opLinkerIt->getNext();
}
if (transType == TTNORMAL) {
appendTransitionOperandConceptLinker(concept,createTransitionOperandConceptLinker(generatingConcept,!existNegation));
appendTransitionOperandConceptLinker(concept,createTransitionOperandConceptLinker(beginState,existNegation));
}
appendTransitionOperandConceptLinker(beginState,createTransitionOperandConceptLinker(propCon,false));
appendTransitionOperandConceptLinker(propCon,createTransitionOperandConceptLinker(endState,false));
//const QList subRoleChainDataList(mRoleSubRoleChainDataHash.values(role));
if (role->getRoleTag() == 1) {
appendTransitionOperandConceptLinker(endState, createTransitionOperandConceptLinker(beginState, false));
} else {
const CRecTravSubRoleChainDataItem& recTravSubRoleChainDataItem(mRoleRecTravSubRoleChainDataHash.value(role));
QSet locUnfoldRoleSet;
generateRoleChainAutomatConcept(role, recTravSubRoleChainDataItem, locUnfoldRoleSet, beginState, endState, transType);
}
// search fitting sub role chains
//bool hasFittingSubRole = false;
//QList subRoleChainDataList(mRoleSubRoleChainDataHash.values(role));
//hasFittingSubRole = !subRoleChainDataList.isEmpty();
//if (hasFittingSubRole) {
// bool transitiveRole = true;
// for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
// CRoleSubRoleChainData subRoleChainData(*it);
// CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
// bool subRoleNegation = subRoleChainData.mInverse;
// CRole* superRole = subRoleChainData.mRole;
// CXLinker* roleChainLinkerIt = subRoleChain->getRoleChainLinker();
// while (roleChainLinkerIt) {
// CRole* chainRole = roleChainLinkerIt->getData();
// if (chainRole != superRole) {
// transitiveRole = false;
// break;
// }
// roleChainLinkerIt = roleChainLinkerIt->getNext();
// }
// }
// if (transitiveRole && subRoleChainDataList.count() > 1) {
// QHash roleCountHash;
// QHash roleChainDataHash;
// for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
// CRoleSubRoleChainData subRoleChainData(*it);
// CRole* superRole = subRoleChainData.mRole;
// roleCountHash.insert(superRole,0);
// roleChainDataHash.insert(superRole,subRoleChainData);
// }
// for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
// CRoleSubRoleChainData subRoleChainData(*it);
// CRole* superRole = subRoleChainData.mRole;
// CSortedNegLinker* superSuperLinkerIt = superRole->getIndirectSuperRoleList();
// while (superSuperLinkerIt) {
// CRole* superSuperRole = superSuperLinkerIt->getData();
// cint64 count = roleCountHash.value(superSuperRole,-1);
// if (count >= 0) {
// roleCountHash.insert(superSuperRole,count+1);
// }
// superSuperLinkerIt = superSuperLinkerIt->getNext();
// }
// }
// QMap countRoleMap;
// for (QHash::const_iterator it = roleCountHash.constBegin(), itEnd = roleCountHash.constEnd(); it != itEnd; ++it) {
// CRole* role = it.key();
// cint64 count = it.value();
// countRoleMap.insertMulti(-count,role);
// }
// QSet locUnfoldRoleSet;
// for (QMap::const_iterator it = countRoleMap.constBegin(), itEnd = countRoleMap.constEnd(); it != itEnd; ++it) {
// CRole* superRole = it.value();
// CRoleSubRoleChainData subRoleChainData(roleChainDataHash.value(superRole));
// CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
// bool subRoleNegation = subRoleChainData.mInverse;
// bool requiresAutomatGeneration = true;
// CSortedNegLinker* superSuperLinkerIt = superRole->getIndirectSuperRoleList();
// while (superSuperLinkerIt) {
// CRole* superSuperRole = superSuperLinkerIt->getData();
// if (locUnfoldRoleSet.contains(superSuperRole)) {
// requiresAutomatGeneration = false;
// break;
// }
// superSuperLinkerIt = superSuperLinkerIt->getNext();
// }
// if (requiresAutomatGeneration) {
// locUnfoldRoleSet.insert(superRole);
// generateRoleChainAutomatConcept(role,superRole,subRoleChain,subRoleNegation,locUnfoldRoleSet,beginState,endState,transType);
// } else {
// ++mStatAutomateTransitiveSavedCount;
// }
// }
// } else {
// for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
// CRoleSubRoleChainData subRoleChainData(*it);
// CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
// bool subRoleNegation = subRoleChainData.mInverse;
// CRole* superRole = subRoleChainData.mRole;
// CSortedNegLinker* superSuperLinkerIt = superRole->getIndirectSuperRoleList();
// QSet locUnfoldRoleSet;
// locUnfoldRoleSet.insert(role);
// while (superSuperLinkerIt) {
// CRole* superSuperRole = superSuperLinkerIt->getData();
// locUnfoldRoleSet.insert(superSuperRole);
// superSuperLinkerIt = superSuperLinkerIt->getNext();
// }
// generateRoleChainAutomatConcept(role,superRole,subRoleChain,subRoleNegation,locUnfoldRoleSet,beginState,endState,transType);
// }
// }
//}
return this;
}
CConcept* CRoleChainAutomataTransformationPreProcess::createAutomatGeneratingConcept(CSortedNegLinker* opLinker, bool negate, CRole* role) {
CConcept* concept = nullptr;
concept = CObjectAllocator::allocateAndConstruct(mMemMan);
concept->initConcept();
cint64 conTag = mNextConceptTag++;
concept->setConceptTag(conTag);
mConVec->setData(conTag,concept);
concept->setOperatorCode(CCAQSOME);
concept->setRole(role);
CSortedNegLinker* opLinkerIt = opLinker;
while (opLinkerIt) {
CConcept* opConcept = opLinkerIt->getData();
bool opNegation = opLinkerIt->isNegated() ^ negate;
appendTransitionOperandConceptLinker(concept,createTransitionOperandConceptLinker(opConcept,opNegation));
opLinkerIt = opLinkerIt->getNext();
}
return concept;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::createInverseRoleChainLinkers() {
FOREACHIT (CRoleChain* roleChain, mInverseUpdateRoleChainSet) {
if (!roleChain->getInverseRoleChainLinker()) {
CXLinker* roleLinkerIt = roleChain->getRoleChainLinker();
while (roleLinkerIt) {
CRole* chainedRole = roleLinkerIt->getData();
CXLinker* invRoleLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(mMemMan);
invRoleLinker->initLinker(chainedRole);
roleChain->prependInverseRoleChainLinker(invRoleLinker);
roleLinkerIt = roleLinkerIt->getNext();
}
}
}
return this;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::createMissingInverseChainedRoles() {
// collect direct and indirect sub roles
QHash > roleTagIndirectSubRoleTagNegationHash;
QHash > roleTagSubRoleTagNegationHash;
qint64 itemCounts = mRoleVec->getItemCount();
for (qint64 i = 0; i < itemCounts; ++i) {
CRole *role = mRoleVec->getData(i);
if (role) {
cint64 roleTag = role->getRoleTag();
CSortedNegLinker* inSuperRoleLinkerIt = role->getIndirectSuperRoleList();
while (inSuperRoleLinkerIt) {
CRole* superRole = inSuperRoleLinkerIt->getData();
cint64 superRoleTag = superRole->getRoleTag();
bool superRoleNeg = inSuperRoleLinkerIt->isNegated();
roleTagIndirectSubRoleTagNegationHash.insertMulti(superRoleTag,QPair(roleTag,superRoleNeg));
inSuperRoleLinkerIt = inSuperRoleLinkerIt->getNext();
}
CSortedNegLinker* superRoleLinkerIt = role->getSuperRoleList();
while (superRoleLinkerIt) {
CRole* superRole = superRoleLinkerIt->getData();
cint64 superRoleTag = superRole->getRoleTag();
bool superRoleNeg = superRoleLinkerIt->isNegated();
roleTagSubRoleTagNegationHash.insertMulti(superRoleTag,QPair(roleTag,superRoleNeg));
superRoleLinkerIt = superRoleLinkerIt->getNext();
}
}
}
// build missing inverse roles
QSet needsInverseRoleSet;
for (qint64 i = 0; i < itemCounts; ++i) {
CRole *role = mRoleVec->getLocalData(i);
if (role) {
if (role->isComplexRole()) {
if (role->getDomainConceptList()) {
needsInverseRoleSet.insert(role);
}
if (hasInverseRole(role) || role->getDomainConceptList() || role->getRangeConceptList()) {
// check whether it is necessary to build additional inverse roles
QList subRoleInvSearchList;
QSet subRoleInvSearchSet;
subRoleInvSearchList.append(role);
subRoleInvSearchSet.insert(role);
while (!subRoleInvSearchList.isEmpty()) {
CRole* subRoleInvSearchRole = subRoleInvSearchList.takeFirst();
QList subRoleChainDataList(mRoleSubRoleChainDataHash.values(subRoleInvSearchRole));
for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
CRoleSubRoleChainData subRoleChainData(*it);
CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
bool subRoleNegation = subRoleChainData.mInverse;
CRole* superRole = subRoleChainData.mRole;
needsInverseRoleSet.insert(superRole);
CXLinker* chainedSubRoleLinkerIt = subRoleChain->getRoleChainLinker();
while (chainedSubRoleLinkerIt) {
CRole* subRole = chainedSubRoleLinkerIt->getData();
needsInverseRoleSet.insert(subRole);
if (!subRoleInvSearchSet.contains(subRole)) {
subRoleInvSearchSet.insert(subRole);
subRoleInvSearchList.append(subRole);
}
chainedSubRoleLinkerIt = chainedSubRoleLinkerIt->getNext();
}
}
}
}
}
}
}
bool updatedInverseRoles = false;
FOREACHIT (CRole* role, needsInverseRoleSet) {
if (!hasInverseRole(role)) {
// build additional inverse role
role = getLocalizedRole(role);
updatedInverseRoles = true;
CRole* inverseRole = CObjectAllocator< CRole >::allocateAndConstruct(mMemMan);
inverseRole->initRole();
cint64 inverseRoleTag = mRoleVec->getItemCount();
inverseRole->setRoleTag(inverseRoleTag);
inverseRole->setRoleComplexity(role->getRoleComplexity());
mRoleVec->setData(inverseRole->getRoleTag(),inverseRole);
CSortedNegLinker* invRoleLinker1 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
invRoleLinker1->init(role,true);
inverseRole->addSuperRoleLinker(invRoleLinker1);
CSortedNegLinker* invRoleLinker2 = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
invRoleLinker2->init(inverseRole,true);
role->addSuperRoleLinker(invRoleLinker2);
CObjectPropertyTermExpression* buildExpression = mRoleObjPropTermHash->value(role);
CInverseObjectPropertyOfExpression* expression = nullptr;
expression = new CInverseObjectPropertyOfExpression(buildExpression);
mExpressionBuildHash->insert(CExpressionHasher(expression),expression);
mInverseObjectPropertyHash->insert(buildExpression,expression);
mInverseObjectPropertyHash->insert(expression,buildExpression);
mExpressionBuildContainerList->append(expression);
mRoleObjPropTermHash->insert(role,expression);
mObjPropTermRoleHash->insert(expression,role);
QList< QPair > subRoleTagList(roleTagSubRoleTagNegationHash.values(role->getRoleTag()));
for (QList< QPair >::const_iterator it = subRoleTagList.constBegin(), itEnd = subRoleTagList.constEnd(); it != itEnd; ++it) {
cint64 subRoleTag = it->first;
CRole* subRole = getLocalizedRole(subRoleTag);
// add new inverse super role
CSortedNegLinker* superRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
superRoleLinker->init(inverseRole,!it->second);
subRole->addSuperRoleLinker(superRoleLinker);
}
QList< QPair > indSubRoleTagList(roleTagIndirectSubRoleTagNegationHash.values(role->getRoleTag()));
for (QList< QPair >::const_iterator it = indSubRoleTagList.constBegin(), itEnd = indSubRoleTagList.constEnd(); it != itEnd; ++it) {
cint64 subRoleTag = it->first;
CRole* subRole = getLocalizedRole(subRoleTag);
// add new inverse super role
CSortedNegLinker* superRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
superRoleLinker->init(inverseRole,!it->second);
subRole->addIndirectSuperRoleLinker(superRoleLinker);
}
// copy indirect super role linker to new inverse role
CSortedNegLinker* inSuperRoleLinkerIt = role->getIndirectSuperRoleList();
while (inSuperRoleLinkerIt) {
CRole* superRole = inSuperRoleLinkerIt->getData();
cint64 superRoleTag = superRole->getRoleTag();
bool superRoleNeg = inSuperRoleLinkerIt->isNegated();
CSortedNegLinker* invSuperRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
invSuperRoleLinker->init(superRole,!superRoleNeg);
inverseRole->addIndirectSuperRoleLinker(invSuperRoleLinker);
roleTagIndirectSubRoleTagNegationHash.insertMulti(superRoleTag,QPair(inverseRoleTag,!superRoleNeg));
inSuperRoleLinkerIt = inSuperRoleLinkerIt->getNext();
}
// copy super role linker to new inverse role
CSortedNegLinker* superRoleLinkerIt = role->getSuperRoleList();
while (superRoleLinkerIt) {
CRole* superRole = superRoleLinkerIt->getData();
cint64 superRoleTag = superRole->getRoleTag();
bool superRoleNeg = superRoleLinkerIt->isNegated();
CSortedNegLinker* invSuperRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
invSuperRoleLinker->init(superRole,!superRoleNeg);
inverseRole->addSuperRoleLinker(invSuperRoleLinker);
roleTagSubRoleTagNegationHash.insertMulti(superRoleTag,QPair(inverseRoleTag,!superRoleNeg));
superRoleLinkerIt = superRoleLinkerIt->getNext();
}
}
}
if (updatedInverseRoles) {
mRoleSubRoleChainDataHash.clear();
collectSubRoleChains();
}
return this;
}
bool CRoleChainAutomataTransformationPreProcess::hasInverseRole(CRole* role, bool searchInverseEquivalent) {
return getInverseRole(role,searchInverseEquivalent) != nullptr;
}
CRole* CRoleChainAutomataTransformationPreProcess::getInverseRole(CRole* role, bool searchInverseEquivalent) {
CRole* inverseRole = role->getInverseRole();
if (inverseRole) {
return inverseRole;
}
CSortedNegLinker< CRole* >* inEqRoleLinkerIt = role->getInverseEquivalentRoleList();
while (inEqRoleLinkerIt) {
CRole* invEqRole = inEqRoleLinkerIt->getData();
bool invEqRoleNeg = inEqRoleLinkerIt->isNegated();
if (invEqRoleNeg) {
return invEqRole;
}
inEqRoleLinkerIt = inEqRoleLinkerIt->getNext();
}
CSortedNegLinker< CRole* >* suberRoleLinkerIt = role->getSuperRoleList();
while (suberRoleLinkerIt) {
CRole* superRole = suberRoleLinkerIt->getData();
bool superRoleNeg = suberRoleLinkerIt->isNegated();
if (superRoleNeg) {
if (!searchInverseEquivalent) {
return superRole;
} else {
CSortedNegLinker< CRole* >* invSuberRoleLinkerIt = superRole->getSuperRoleList();
while (invSuberRoleLinkerIt) {
if (invSuberRoleLinkerIt->getData()->getRoleTag() == role->getRoleTag()) {
return superRole;
}
invSuberRoleLinkerIt = invSuberRoleLinkerIt->getNext();
}
}
}
suberRoleLinkerIt = suberRoleLinkerIt->getNext();
}
return nullptr;
}
bool CRoleChainAutomataTransformationPreProcess::hasInversedOrNonInversedSuperRole(CRole* role, CRole* testingSuperRole) {
return hasSuperRole(role,testingSuperRole,false,false);
}
bool CRoleChainAutomataTransformationPreProcess::hasInversedSuperRole(CRole* role, CRole* testingSuperRole) {
return hasSuperRole(role,testingSuperRole,true,true);
}
bool CRoleChainAutomataTransformationPreProcess::hasNonInversedSuperRole(CRole* role, CRole* testingSuperRole) {
return hasSuperRole(role,testingSuperRole,true,false);
}
bool CRoleChainAutomataTransformationPreProcess::hasSuperRole(CRole* role, CRole* testingSuperRole, bool superRoleInversedRequired) {
return hasSuperRole(role,testingSuperRole,true,superRoleInversedRequired);
}
bool CRoleChainAutomataTransformationPreProcess::hasSuperRole(CRole* role, CRole* testingSuperRole, bool testInversed, bool superRoleInversedRequired) {
for (CSortedNegLinker* superRoleLinkerIt = role->getIndirectSuperRoleList(); superRoleLinkerIt; superRoleLinkerIt = superRoleLinkerIt->getNext()) {
CRole* superRole = superRoleLinkerIt->getData();
if (superRole == testingSuperRole) {
if (testInversed) {
if (superRoleLinkerIt->isNegated() == superRoleInversedRequired) {
return true;
}
} else {
return true;
}
}
}
return false;
}
bool CRoleChainAutomataTransformationPreProcess::isChainLinkerImplicit(CXLinker* testingImplicitChainLinker, CXLinker* chainLinker, bool inversedTesting) {
CXLinker* testingChainLinkerIt = testingImplicitChainLinker;
CXLinker* chainLinkerIt = chainLinker;
for (; testingChainLinkerIt && chainLinkerIt; testingChainLinkerIt = testingChainLinkerIt->getNext(), chainLinkerIt = chainLinkerIt->getNext()) {
CRole* testingChainRole = testingChainLinkerIt->getData();
CRole* chainRole = chainLinkerIt->getData();
if (!hasSuperRole(testingChainRole,chainRole,inversedTesting)) {
return false;
}
}
if (testingChainLinkerIt || chainLinkerIt) {
return false;
}
return true;
}
bool CRoleChainAutomataTransformationPreProcess::isTransitiveChainData(const CRoleSubRoleChainData& chainData) {
cint64 transChainedRoleCount = 0;
CRole* chainSuperRole = chainData.mRole;
for (CXLinker* chainLinkerIt = chainData.mRoleChain->getRoleChainLinker(); chainLinkerIt ; chainLinkerIt = chainLinkerIt->getNext()) {
CRole* chainedRole = chainLinkerIt->getData();
if (chainedRole != chainSuperRole) {
return false;
}
++transChainedRoleCount;
}
if (transChainedRoleCount == 2) {
return true;
}
return false;
}
bool CRoleChainAutomataTransformationPreProcess::isChainDataImplicit(const CRoleSubRoleChainData& testingImplicitChainData, const CRoleSubRoleChainData& chainData) {
// the testingImplicitChainData is implicit if every used role is a subrole of the corresponding role in chainData
CRole* testingChainSuperRole = testingImplicitChainData.mRole;
CRole* chainSuperRole = chainData.mRole;
bool inversedTesting = chainData.mInverse ^ testingImplicitChainData.mInverse;
if (hasInversedOrNonInversedSuperRole(testingChainSuperRole,chainSuperRole)) {
if (!inversedTesting && hasNonInversedSuperRole(testingChainSuperRole,chainSuperRole)) {
CXLinker* testingChainLinker = testingImplicitChainData.mRoleChain->getRoleChainLinker();
CXLinker* chainLinker = chainData.mRoleChain->getRoleChainLinker();
if (isChainLinkerImplicit(testingChainLinker,chainLinker,false)) {
return true;
}
}
if (inversedTesting && hasInversedSuperRole(testingChainSuperRole,chainSuperRole)) {
CXLinker* testingChainLinker = testingImplicitChainData.mRoleChain->getRoleChainLinker();
CXLinker* chainLinker = chainData.mRoleChain->getInverseRoleChainLinker();
if (isChainLinkerImplicit(testingChainLinker,chainLinker,true)) {
return true;
}
}
}
return false;
}
bool CRoleChainAutomataTransformationPreProcess::isChainDataRecursiveTraversalCritical(CRole* role, const CRoleSubRoleChainData& chainData) {
// test first and last chain linker
CRole* chainSuperRole = chainData.mRole;
if (chainSuperRole != role) {
if (!hasInversedOrNonInversedSuperRole(role,chainSuperRole)) {
CXLinker* chainLinkerIt = chainData.mRoleChain->getRoleChainLinker();
if (chainLinkerIt->getData() == chainSuperRole) {
return true;
}
if (chainLinkerIt->getLastListLink()->getData() == chainSuperRole) {
return true;
}
}
}
return false;
}
QList CRoleChainAutomataTransformationPreProcess::getRelevantChainDataList(CRole* role, const QList& roleSubChainDataList) {
QList relevantChainDataList;
for (QList::const_iterator it = roleSubChainDataList.constBegin(), itEnd = roleSubChainDataList.constEnd(); it != itEnd; ++it) {
const CRoleSubRoleChainData& roleChainData(*it);
bool hasImplicitRoleChainData = false;
QList::const_iterator it2 = it;
for (++it2; it2 != itEnd && !hasImplicitRoleChainData; ++it2) {
const CRoleSubRoleChainData& roleChainData2(*it2);
if (isChainDataImplicit(roleChainData,roleChainData2)) {
hasImplicitRoleChainData = true;
}
}
for (QList::const_iterator it2 = relevantChainDataList.constBegin(), it2End = relevantChainDataList.constEnd(); it2 != it2End && !hasImplicitRoleChainData; ++it2) {
const CRoleSubRoleChainData& roleChainData2(*it2);
if (isChainDataImplicit(roleChainData,roleChainData2)) {
hasImplicitRoleChainData = true;
}
}
if (!hasImplicitRoleChainData) {
relevantChainDataList.append(roleChainData);
}
}
return relevantChainDataList;
}
QHash CRoleChainAutomataTransformationPreProcess::getRelevantRecursiveTraversalCriticalRoles(QHash* criticalRoleNegationHash) {
// return the most general roles
QHash criticalGeneralRoleNegationHash;
for (QHash::const_iterator it = criticalRoleNegationHash->constBegin(), itEnd = criticalRoleNegationHash->constEnd(); it != itEnd; ++it) {
CRole* role = it.key();
bool roleInversed = it.value();
bool hasCriticalSuperRole = false;
QHash::const_iterator it2 = it;
for (++it2; it2 != itEnd && !hasCriticalSuperRole; ++it2) {
CRole* role2 = it2.key();
bool role2Inversed = it2.value();
if (role != role2) {
if (hasInversedOrNonInversedSuperRole(role,role2)) {
hasCriticalSuperRole = true;
}
}
}
for (QHash::const_iterator it2 = criticalGeneralRoleNegationHash.constBegin(), it2End = criticalGeneralRoleNegationHash.constEnd(); it2 != it2End && !hasCriticalSuperRole; ++it2) {
CRole* role2 = it2.key();
bool role2Inversed = it2.value();
if (role != role2) {
if (hasInversedOrNonInversedSuperRole(role,role2)) {
hasCriticalSuperRole = true;
}
}
}
if (!hasCriticalSuperRole) {
criticalGeneralRoleNegationHash.insert(role,roleInversed);
}
}
return criticalGeneralRoleNegationHash;
}
bool CRoleChainAutomataTransformationPreProcess::collectRecursiveTraversalCriticalRoles(CRole* role, const CRoleSubRoleChainData& chainData, QHash* criticalRoleNegationHash) {
if (isChainDataRecursiveTraversalCritical(role,chainData)) {
CRole* chainSuperRole = chainData.mRole;
bool negatedSuperRole = chainData.mInverse;
criticalRoleNegationHash->insert(chainSuperRole,negatedSuperRole);
return true;
}
return false;
}
bool CRoleChainAutomataTransformationPreProcess::requiresRecursiveTraversalForRole(CRole* role, const CRoleSubRoleChainData& chainData, QHash* criticalRoleNegationHash) {
CRole* chainSuperRole = chainData.mRole;
for (CSortedNegLinker* superRoleIt = chainSuperRole->getIndirectSuperRoleList(); superRoleIt; superRoleIt = superRoleIt->getNext()) {
CRole* superRole = superRoleIt->getData();
bool superRoleNeg = superRoleIt->isNegated() ^ chainData.mInverse;
if (criticalRoleNegationHash->contains(superRole)) {
return true;
}
}
return false;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::collectSubRoleChains() {
qint64 itemCounts = mRoleVec->getItemCount();
for (qint64 i = 0; i < itemCounts; ++i) {
CRole *role = mRoleVec->getData(i);
if (role) {
if (role->isComplexRole()) {
CXLinker* roleChainLinkerIt = role->getRoleChainSuperSharingLinker();
while (roleChainLinkerIt) {
CRoleChain* roleChain = roleChainLinkerIt->getData();
if (!roleChain->getInverseRoleChainLinker()) {
mInverseUpdateRoleChainSet.insert(roleChain);
}
CSortedNegLinker< CRole* >* suberRoleLinkerIt = role->getIndirectSuperRoleList();
while (suberRoleLinkerIt) {
CRole* superRole = suberRoleLinkerIt->getData();
bool superRoleNeg = suberRoleLinkerIt->isNegated();
superRole = mRoleVec->getData(superRole->getRoleTag());
mRoleSubRoleChainDataHash.insertMulti(superRole,CRoleSubRoleChainData(role,roleChain,superRoleNeg));
suberRoleLinkerIt = suberRoleLinkerIt->getNext();
}
roleChainLinkerIt = roleChainLinkerIt->getNext();
}
}
}
}
return this;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::createRecursiveTraversalData() {
CRole* currentRole = nullptr;
QList roleSubChainDataList;
for (QHash::const_iterator it = mRoleSubRoleChainDataHash.constBegin(), itEnd = mRoleSubRoleChainDataHash.constEnd(); it != itEnd; ++it) {
CRole* role(it.key());
const CRoleSubRoleChainData& roleSubChainData(it.value());
if (currentRole != role) {
if (currentRole) {
addRecursiveTraversalData(currentRole,roleSubChainDataList);
currentRole = nullptr;
roleSubChainDataList.clear();
}
currentRole = role;
}
roleSubChainDataList.append(roleSubChainData);
}
if (currentRole) {
addRecursiveTraversalData(currentRole,roleSubChainDataList);
}
return this;
}
CRoleChainAutomataTransformationPreProcess* CRoleChainAutomataTransformationPreProcess::addRecursiveTraversalData(CRole* role, const QList& roleSubChainDataList) {
//if (CIRIName::getRecentIRIName(role->getPropertyNameLinker()) == "#isInLawOf") {
// bool debug = true;
//}
QList relevantChainDataList(getRelevantChainDataList(role,roleSubChainDataList));
CRecTravSubRoleChainDataItem& recTravSubRoleChainData = mRoleRecTravSubRoleChainDataHash[role];
recTravSubRoleChainData.mRole = role;
QHash criticalRoleNegationHash;
bool criticalRecursiveTraversalRoles = false;
for (QList::const_iterator it = relevantChainDataList.constBegin(), itEnd = relevantChainDataList.constEnd(); it != itEnd; ++it) {
const CRoleSubRoleChainData& chainData(*it);
criticalRecursiveTraversalRoles |= collectRecursiveTraversalCriticalRoles(role,chainData,&criticalRoleNegationHash);
}
if (!criticalRecursiveTraversalRoles) {
recTravSubRoleChainData.mDirectSubRoleChainDataList = relevantChainDataList;
} else {
QHash relevantCriticalRoleNegationHash(getRelevantRecursiveTraversalCriticalRoles(&criticalRoleNegationHash));
for (QList::const_iterator it = relevantChainDataList.constBegin(), itEnd = relevantChainDataList.constEnd(); it != itEnd; ++it) {
const CRoleSubRoleChainData& chainData(*it);
if (!requiresRecursiveTraversalForRole(role,chainData,&relevantCriticalRoleNegationHash)) {
recTravSubRoleChainData.mDirectSubRoleChainDataList.append(chainData);
}
}
for (QHash::const_iterator it = relevantCriticalRoleNegationHash.constBegin(), itEnd = relevantCriticalRoleNegationHash.constEnd(); it != itEnd; ++it) {
CRole* role(it.key());
bool inversed(it.value());
if (recTravSubRoleChainData.mRole->isSymmetric() && recTravSubRoleChainData.mRole->getInverseRole() == recTravSubRoleChainData.mRole) {
recTravSubRoleChainData.mRecTraversalSubRoleList.append(TRoleNegationPair(role,!inversed));
}
recTravSubRoleChainData.mRecTraversalSubRoleList.append(TRoleNegationPair(role,inversed));
}
}
return this;
}
CConcept* CRoleChainAutomataTransformationPreProcess::createTransitionConcept(CRole* role, TRANSLATIONTYPE transType) {
CConcept* concept = nullptr;
concept = CObjectAllocator::allocateAndConstruct(mMemMan);
concept->initConcept();
cint64 conTag = mNextConceptTag++;
concept->setConceptTag(conTag);
mConVec->setData(conTag,concept);
concept->setRole(role);
cint64 opCode = CCAQALL;
if (transType == TTNORMAL) {
opCode = CCAQALL;
} else if (transType == TTIMPL) {
opCode = CCIMPLAQALL;
} else if (transType == TTBRANCH) {
opCode = CCBRANCHAQALL;
} else if (transType == TTPROPBIND) {
opCode = CCPBINDAQALL;
} else if (transType == TTBACKPROP) {
opCode = CCVARPBACKAQALL;
} else if (transType == TTVARBIND) {
opCode = CCVARBINDAQALL;
}
concept->setOperatorCode(opCode);
++mStatAutomateTransitionConceptCount;
return concept;
}
CConcept* CRoleChainAutomataTransformationPreProcess::createNominalConcept(CIndividual* individual) {
individual = CConceptRoleIndividualLocator::getLocatedIndividual(individual,mOntology);
CConcept* concept = individual->getIndividualNominalConcept();
if (!concept) {
concept = CObjectAllocator::allocateAndConstruct(mMemMan);
concept->initConcept();
cint64 conTag = mNextConceptTag++;
concept->setConceptTag(conTag);
mConVec->setData(conTag,concept);
concept->setOperatorCode(CCNOMINAL);
concept->setNominalIndividual(individual);
individual->setIndividualNominalConcept(concept);
}
return concept;
}
CConcept* CRoleChainAutomataTransformationPreProcess::createStateConcept(TRANSLATIONTYPE transType) {
CConcept* concept = nullptr;
concept = CObjectAllocator::allocateAndConstruct(mMemMan);
concept->initConcept();
cint64 conTag = mNextConceptTag++;
concept->setConceptTag(conTag);
mConVec->setData(conTag,concept);
cint64 opCode = CCAQAND;
if (transType == TTNORMAL) {
opCode = CCAQAND;
} else if (transType == TTIMPL) {
opCode = CCIMPLAQAND;
} else if (transType == TTBRANCH) {
opCode = CCBRANCHAQAND;
} else if (transType == TTPROPBIND) {
opCode = CCPBINDAQAND;
} else if (transType == TTBACKPROP) {
opCode = CCVARPBACKAQAND;
} else if (transType == TTVARBIND) {
opCode = CCVARBINDAQAND;
}
concept->setOperatorCode(opCode);
++mStatAutomateStateConceptCount;
return concept;
}
CSortedNegLinker* CRoleChainAutomataTransformationPreProcess::createTransitionOperandConceptLinker(CConcept* operandConcept, bool negation) {
CSortedNegLinker* opConceptLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan);
opConceptLinker->init(operandConcept,negation);
return opConceptLinker;
}
CConcept* CRoleChainAutomataTransformationPreProcess::appendTransitionOperandConceptLinker(CConcept* concept, CSortedNegLinker* opLinker) {
//for (CSortedNegLinker* opLinkerIt = concept->getOperandList(); opLinkerIt; opLinkerIt = opLinkerIt->getNext()) {
// CConcept* opCon = opLinkerIt->getData();
// if (opCon == opLinker->getData()) {
// if (opLinkerIt->isNegated() == opLinker->isNegated()) {
// bool bug = true;
// }
// }
//}
concept->addOperandLinker(opLinker);
concept->incOperandCount();
return concept;
}
bool CRoleChainAutomataTransformationPreProcess::generateRoleChainAutomatConcept(CRole* lastRole, const CRecTravSubRoleChainDataItem& recTravSubRoleChainDataItem, QSet& alreadyUnfoldRoleSet, CConcept* beginConcept, CConcept* endConcept, TRANSLATIONTYPE transType) {
const QList& subRoleChainDataList(recTravSubRoleChainDataItem.mDirectSubRoleChainDataList);
generateRoleChainAutomatConcept(lastRole,subRoleChainDataList,alreadyUnfoldRoleSet,beginConcept,endConcept,transType);
const QList& recTravSubRoleList(recTravSubRoleChainDataItem.mRecTraversalSubRoleList);
for (QList::const_iterator it = recTravSubRoleList.constBegin(), itEnd = recTravSubRoleList.constEnd(); it != itEnd; ++it) {
TRoleNegationPair recTravSubRoleNegPair(*it);
CRole* recTravSubRole(recTravSubRoleNegPair.first);
if (!alreadyUnfoldRoleSet.contains(recTravSubRole)) {
bool recTravSubRoleInversed(recTravSubRoleNegPair.second);
if (recTravSubRoleInversed) {
recTravSubRole = getInverseRole(recTravSubRole);
}
QSet locUnfoldRoleSet(alreadyUnfoldRoleSet);
locUnfoldRoleSet.insert(recTravSubRole);
CSortedNegLinker* superSuperLinkerIt = recTravSubRole->getIndirectSuperRoleList();
while (superSuperLinkerIt) {
CRole* superSuperRole = superSuperLinkerIt->getData();
locUnfoldRoleSet.insert(superSuperRole);
superSuperLinkerIt = superSuperLinkerIt->getNext();
}
CConcept* recTravSubBeginConcept = createStateConcept(transType);
CConcept* recTravSubEndConcept = createStateConcept(transType);
appendTransitionOperandConceptLinker(beginConcept,createTransitionOperandConceptLinker(recTravSubBeginConcept,false));
appendTransitionOperandConceptLinker(recTravSubEndConcept,createTransitionOperandConceptLinker(endConcept,false));
CConcept* recTravPropCon = createTransitionConcept(recTravSubRole,transType);
appendTransitionOperandConceptLinker(recTravSubBeginConcept,createTransitionOperandConceptLinker(recTravPropCon,false));
appendTransitionOperandConceptLinker(recTravPropCon,createTransitionOperandConceptLinker(recTravSubEndConcept,false));
const CRecTravSubRoleChainDataItem& nextRecTravSubRoleChainDataItem(mRoleRecTravSubRoleChainDataHash.value(recTravSubRole));
generateRoleChainAutomatConcept(recTravSubRole,nextRecTravSubRoleChainDataItem,locUnfoldRoleSet,recTravSubBeginConcept,recTravSubEndConcept,transType);
}
}
return true;
}
bool CRoleChainAutomataTransformationPreProcess::generateRoleChainAutomatConcept(CRole* lastRole, const QList& subRoleChainDataList, QSet& alreadyUnfoldRoleSet, CConcept* beginConcept, CConcept* endConcept, TRANSLATIONTYPE transType) {
for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
CRoleSubRoleChainData subRoleChainData(*it);
CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
bool subRoleNegation = subRoleChainData.mInverse;
CRole* superRoleChain = subRoleChainData.mRole;
QSet locUnfoldRoleSet(alreadyUnfoldRoleSet);
locUnfoldRoleSet.insert(lastRole);
CSortedNegLinker* superSuperLinkerIt = superRoleChain->getIndirectSuperRoleList();
while (superSuperLinkerIt) {
CRole* superSuperRole = superSuperLinkerIt->getData();
locUnfoldRoleSet.insert(superSuperRole);
superSuperLinkerIt = superSuperLinkerIt->getNext();
}
generateRoleChainAutomatConcept(lastRole,superRoleChain,subRoleChain,subRoleNegation,locUnfoldRoleSet,beginConcept,endConcept,transType);
}
return true;
}
bool CRoleChainAutomataTransformationPreProcess::generateRoleChainAutomatConcept(CRole* lastRole, CRole* superRole, CRoleChain* descendingRoleChain, bool negatedChain, QSet& alreadyUnfoldRoleSet, CConcept* beginConcept, CConcept* endConcept, TRANSLATIONTYPE transType) {
// TODO:
// generate for each role in the role chain a concept
// connect all concepts with each other,
// append the first connected concept to the appending list
// return later the last connected concept
// for each generated concept in the role chain
// check whether related role is complex and is not already used above (hash)
// recursive call to generate concepts for each role chain and sub role
CXLinker* chainedRoleLinker = nullptr;
CXLinker* inverseChainedRoleLinker = nullptr;
bool useInverseRoles = negatedChain;
if (!negatedChain) {
chainedRoleLinker = descendingRoleChain->getRoleChainLinker();
inverseChainedRoleLinker = descendingRoleChain->getInverseRoleChainLinker();
} else {
chainedRoleLinker = descendingRoleChain->getInverseRoleChainLinker();
inverseChainedRoleLinker = descendingRoleChain->getRoleChainLinker();
}
CConcept* connectBeginCon = nullptr;
CConcept* connectEndCon = nullptr;
CConcept* firstConcept = nullptr;
CConcept* lastConcept = nullptr;
bool transStart = false;
bool transEnd = false;
CRole* testRole = superRole;
if (useInverseRoles && lastRole != superRole) {
testRole = getInverseRole(superRole);
}
while (chainedRoleLinker) {
CRole* subRole = chainedRoleLinker->getData();
if (useInverseRoles) {
// search inverse role
subRole = getInverseRole(subRole);
}
subRole = mRoleVec->getData(subRole->getRoleTag());
if (!firstConcept && subRole == testRole && !transStart) {
// transitive start
transStart = true;
} else if (!chainedRoleLinker->hasNext() && subRole == testRole) {
// transitive end
transEnd = true;
} else if (!alreadyUnfoldRoleSet.contains(subRole)) {
// test recursive call
CConcept* subBeginConcept = createStateConcept(transType);
CConcept* propCon = createTransitionConcept(subRole,transType);
CConcept* subEndConcept = createStateConcept(transType);
if (!connectBeginCon) {
connectBeginCon = subBeginConcept;
}
if (connectEndCon) {
appendTransitionOperandConceptLinker(connectEndCon,createTransitionOperandConceptLinker(subBeginConcept,false));
}
connectEndCon = subEndConcept;
if (!firstConcept) {
firstConcept = propCon;
}
appendTransitionOperandConceptLinker(subBeginConcept,createTransitionOperandConceptLinker(propCon,false));
appendTransitionOperandConceptLinker(propCon,createTransitionOperandConceptLinker(subEndConcept,false));
const CRecTravSubRoleChainDataItem& recTravSubRoleChainDataItem(mRoleRecTravSubRoleChainDataHash.value(subRole));
generateRoleChainAutomatConcept(subRole,recTravSubRoleChainDataItem,alreadyUnfoldRoleSet,subBeginConcept,subEndConcept,transType);
//const QList& subRoleChainDataList(recTravSubRoleChainDataItem.mDirectSubRoleChainDataList);
//generateRoleChainAutomatConcept(subRole,subRoleChainDataList,alreadyUnfoldRoleSet,subBeginConcept,subEndConcept,transType);
////for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
//// CRoleSubRoleChainData subRoleChainData(*it);
//// CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
//// bool subRoleNegation = subRoleChainData.mInverse;
//// CRole* superRoleChain = subRoleChainData.mRole;
//// QSet locUnfoldRoleSet(alreadyUnfoldRoleSet);
//// locUnfoldRoleSet.insert(subRole);
//// CSortedNegLinker* superSuperLinkerIt = superRoleChain->getIndirectSuperRoleList();
//// while (superSuperLinkerIt) {
//// CRole* superSuperRole = superSuperLinkerIt->getData();
//// locUnfoldRoleSet.insert(superSuperRole);
//// superSuperLinkerIt = superSuperLinkerIt->getNext();
//// }
//// generateRoleChainAutomatConcept(subRole,superRoleChain,subRoleChain,subRoleNegation,locUnfoldRoleSet,subBeginConcept,subEndConcept,transType);
////}
//const QList& recTravSubRoleList(recTravSubRoleChainDataItem.mRecTraversalSubRoleList);
//for (QList::const_iterator it = recTravSubRoleList.constBegin(), itEnd = recTravSubRoleList.constEnd(); it != itEnd; ++it) {
// TRoleNegationPair recTravSubRoleNegPair(*it);
// CRole* recTravSubRole(recTravSubRoleNegPair.first);
// bool recTravSubRoleInversed(recTravSubRoleNegPair.second);
// if (recTravSubRoleInversed) {
// recTravSubRole = getInverseRole(recTravSubRole);
// }
// CConcept* recTravSubBeginConcept = createStateConcept(transType);
// CConcept* recTravSubEndConcept = createStateConcept(transType);
// appendTransitionOperandConceptLinker(subBeginConcept,createTransitionOperandConceptLinker(recTravSubBeginConcept,false));
// appendTransitionOperandConceptLinker(recTravSubEndConcept,createTransitionOperandConceptLinker(subEndConcept,false));
// CConcept* recTravPropCon = createTransitionConcept(recTravSubRole,transType);
// appendTransitionOperandConceptLinker(recTravSubBeginConcept,createTransitionOperandConceptLinker(recTravPropCon,false));
// appendTransitionOperandConceptLinker(recTravPropCon,createTransitionOperandConceptLinker(recTravSubEndConcept,false));
// generateRoleChainAutomatConcept(recTravSubRole,subRoleChainDataList,alreadyUnfoldRoleSet,recTravSubBeginConcept,recTravSubEndConcept,transType);
//}
//// search fitting sub role chains
////bool hasFittingSubRole = false;
////QList subRoleChainDataList(mRoleSubRoleChainDataHash.values(subRole));
////hasFittingSubRole = !subRoleChainDataList.isEmpty();
////if (hasFittingSubRole) {
//// for (QList::const_iterator it = subRoleChainDataList.constBegin(), itEnd = subRoleChainDataList.constEnd(); it != itEnd; ++it) {
//// CRoleSubRoleChainData subRoleChainData(*it);
//// CRoleChain* subRoleChain = subRoleChainData.mRoleChain;
//// bool subRoleNegation = subRoleChainData.mInverse;
//// CRole* superRoleChain = subRoleChainData.mRole;
//// QSet locUnfoldRoleSet(alreadyUnfoldRoleSet);
//// locUnfoldRoleSet.insert(subRole);
//// CSortedNegLinker* superSuperLinkerIt = superRoleChain->getIndirectSuperRoleList();
//// while (superSuperLinkerIt) {
//// CRole* superSuperRole = superSuperLinkerIt->getData();
//// locUnfoldRoleSet.insert(superSuperRole);
//// superSuperLinkerIt = superSuperLinkerIt->getNext();
//// }
//// generateRoleChainAutomatConcept(subRole,superRoleChain,subRoleChain,subRoleNegation,locUnfoldRoleSet,subBeginConcept,subEndConcept,transType);
//// }
////}
lastConcept = propCon;
} else {
// error, not allowed construct
bool bug = true;
}
chainedRoleLinker = chainedRoleLinker->getNext();
}
if (transStart && !transEnd) {
//if (lastRole != testRole) {
// CConcept* tmpEndConcept = createStateConcept(transType);
// appendTransitionOperandConceptLinker(tmpEndConcept,createTransitionOperandConceptLinker(endConcept,false));
// endConcept = tmpEndConcept;
//}
appendTransitionOperandConceptLinker(endConcept,createTransitionOperandConceptLinker(connectBeginCon,false));
appendTransitionOperandConceptLinker(connectEndCon,createTransitionOperandConceptLinker(endConcept,false));
} else if (transEnd && !transStart) {
//if (lastRole != testRole) {
// CConcept* tmpBeginConcept = createStateConcept(transType);
// appendTransitionOperandConceptLinker(beginConcept,createTransitionOperandConceptLinker(tmpBeginConcept,false));
// beginConcept = tmpBeginConcept;
//}
appendTransitionOperandConceptLinker(connectEndCon,createTransitionOperandConceptLinker(beginConcept,false));
appendTransitionOperandConceptLinker(beginConcept,createTransitionOperandConceptLinker(connectBeginCon,false));
} else if (transStart && transEnd && !firstConcept) {
//if (lastRole != testRole) {
// CConcept* tmpBeginConcept = createStateConcept(transType);
// appendTransitionOperandConceptLinker(beginConcept,createTransitionOperandConceptLinker(tmpBeginConcept,false));
// beginConcept = tmpBeginConcept;
// CConcept* tmpEndConcept = createStateConcept(transType);
// appendTransitionOperandConceptLinker(tmpEndConcept,createTransitionOperandConceptLinker(endConcept,false));
// endConcept = tmpEndConcept;
// CConcept* propCon = createTransitionConcept(testRole,transType);
// appendTransitionOperandConceptLinker(tmpBeginConcept,createTransitionOperandConceptLinker(propCon,false));
// appendTransitionOperandConceptLinker(propCon,createTransitionOperandConceptLinker(tmpEndConcept,false));
//}
appendTransitionOperandConceptLinker(endConcept,createTransitionOperandConceptLinker(beginConcept,false));
} else if (!transStart && !transEnd) {
if (connectBeginCon && connectEndCon) {
appendTransitionOperandConceptLinker(beginConcept,createTransitionOperandConceptLinker(connectBeginCon,false));
appendTransitionOperandConceptLinker(connectEndCon,createTransitionOperandConceptLinker(endConcept,false));
}
} else {
// error, not allowed construct
}
return true;
}
CRole* CRoleChainAutomataTransformationPreProcess::getLocalizedRole(CRole* role) {
return getLocalizedRole(role->getRoleTag());
}
CRole* CRoleChainAutomataTransformationPreProcess::getLocalizedRole(cint64 roleTag) {
CRole* role = mRoleVec->getData(roleTag);
if (!mRoleVec->hasLocalData(roleTag)) {
role = CConceptRoleIndividualLocator::getLocatedRole(role,mOntology);
}
return role;
}
}; // end namespace Preprocess
}; // end namespace Reasoner
}; // end namespace Konclude