/*
* 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 "CMappingUpdaterPreProcess.h"
namespace Konclude {
namespace Reasoner {
namespace Preprocess {
CMappingUpdaterPreProcess::CMappingUpdaterPreProcess() {
}
CMappingUpdaterPreProcess::~CMappingUpdaterPreProcess() {
}
CConcreteOntology *CMappingUpdaterPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
if (ontology) {
tbox = ontology->getDataBoxes()->getTBox();
abox = ontology->getDataBoxes()->getABox();
rbox = ontology->getDataBoxes()->getRBox();
mBox = ontology->getDataBoxes()->getMBox();
mBuildConstructFlags = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags();
mRoleVec = rbox->getRoleVector();
mConceptVec = tbox->getConceptVector();
mIndiVec = abox->getIndividualVector();
mRoleObjPropTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleObjectPropertyTermMappingHash();
mObjPropTermRoleHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermRoleMappingHash();
mRoleDataPropTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getRoleDataPropertyTermMappingHash();
mDataPropTermRoleHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getDataPropertyTermRoleMappingHash();
mClassTermConceptHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermConceptMappingHash();
mConceptClassTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getConceptClassTermMappingHash();
mIndiTermIndiHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getIndividulTermIndiMappingHash();
mIndiIndiTermHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getIndiIndividulTermMappingHash();
mDeclarationAxiomSet = ontology->getBuildData()->getDeclarationAxiomSet();
mClassTermClassAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getClassTermExpressionClassAxiomExpressionHash();
mObjPropTermObjPropAxiomHash = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getObjectPropertyTermObjectPropertyAxiomHash();
mNameConceptHash = ontology->getStringMapping()->getClassNameConceptMappingHash();
mNameRoleHash = ontology->getStringMapping()->getPropertyNameRoleMappingHash();
mNameIndiHash = ontology->getStringMapping()->getIndividualNameIndividualMappingHash();
mActiveEntityVector = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getActiveEntityVector();
qint64 rolesStartUpdateInd = mRoleVec->getReferencedItemCount();
qint64 rolesCounts = mRoleVec->getItemCount();
for (qint64 i = rolesStartUpdateInd; i < rolesCounts; ++i) {
CRole *role = mRoleVec->getLocalData(i);
if (role) {
if (role->hasPropertyName()) {
mNameRoleHash->insert(CIRIName::getRecentIRIName(role->getPropertyNameLinker()),role);
}
CObjectPropertyTermExpression* objPropTerm = mRoleObjPropTermHash->value(role,nullptr);
if (objPropTerm) {
CRole* prevRole = mRoleVec->getReferenceData(i);
if (prevRole) {
objPropTerm = mRoleObjPropTermHash->value(prevRole,nullptr);
}
if (objPropTerm) {
mRoleObjPropTermHash->insert(role,objPropTerm);
mObjPropTermRoleHash->insert(objPropTerm,role);
}
}
}
}
qint64 conStartUpdateInd = mConceptVec->getReferencedItemCount();
qint64 conCounts = mConceptVec->getItemCount();
for (qint64 i = 0; i < conCounts; ++i) {
CConcept *concept = mConceptVec->getLocalData(i);
if (concept) {
if (concept->hasClassName()) {
mNameConceptHash->insert(CIRIName::getRecentIRIName(concept->getClassNameLinker()),concept);
}
if (i < conStartUpdateInd) {
CClassTermExpression* classTerm = mConceptClassTermHash->value(concept,nullptr);
if (classTerm) {
CConcept* prevConcept = mConceptVec->getReferenceData(i);
if (prevConcept) {
classTerm = mConceptClassTermHash->value(prevConcept,nullptr);
}
if (classTerm) {
mConceptClassTermHash->insert(concept,classTerm);
mClassTermConceptHash->insert(classTerm,concept);
}
}
}
}
}
}
qint64 indiStartUpdateInd = mIndiVec->getReferencedItemCount();
qint64 indiCounts = mIndiVec->getItemCount();
for (qint64 i = 0; i < indiCounts; ++i) {
CIndividual *indi = mIndiVec->getLocalData(i);
if (indi) {
if (indi->hasIndividualName()) {
mNameIndiHash->insert(CIRIName::getRecentIRIName(indi->getIndividualNameLinker()),indi);
}
if (i < indiStartUpdateInd) {
CIndividualTermExpression* indiTerm = mIndiIndiTermHash->value(indi,nullptr);
if (indiTerm) {
CIndividual* prevIndi = mIndiVec->getReferenceData(i);
if (prevIndi) {
indiTerm = mIndiIndiTermHash->value(prevIndi,nullptr);
}
if (indiTerm) {
mIndiIndiTermHash->insert(indi,indiTerm);
mIndiTermIndiHash->insert(indiTerm,indi);
}
}
}
}
}
collectActiveOntologyItemsFromActiveEntities();
return ontology;
}
bool CMappingUpdaterPreProcess::collectActiveOntologyItemsFromActiveEntities() {
CBOXSET* activeClassConceptSet = tbox->getActiveClassConceptSet();
activeClassConceptSet->clear();
CBOXSET* activeIndividualSet = abox->getActiveIndividualSet();
activeIndividualSet->clear();
CBOXSET* activeRoleSet = rbox->getActivePropertyRoleSet();
activeRoleSet->clear();
CActiveEntityIterator activeEntityIterator(mActiveEntityVector->getActiveEntityIterator());
while (activeEntityIterator.hasNextActiveEntity()) {
CExpressionEntity* expressionEntity = activeEntityIterator.getNextActiveEntity(true);
if (expressionEntity) {
CClassExpression* classExpression = dynamic_cast(expressionEntity);
if (classExpression) {
CConcept* concept = mClassTermConceptHash->value(classExpression);
if (concept) {
activeClassConceptSet->insert(concept);
}
} else {
CNamedIndividualExpression* namedIndiExpression = dynamic_cast(expressionEntity);
if (namedIndiExpression) {
CIndividual* individual = mIndiTermIndiHash->value(namedIndiExpression);
if (individual) {
activeIndividualSet->insert(individual);
}
} else {
CAnonymousIndividualExpression* anoIndiExpression = dynamic_cast(expressionEntity);
if (anoIndiExpression) {
CIndividual* individual = mIndiTermIndiHash->value(anoIndiExpression);
if (individual) {
activeIndividualSet->insert(individual);
}
} else {
CObjectPropertyExpression* objPropertyExpression = dynamic_cast(expressionEntity);
if (objPropertyExpression) {
CRole* role = mObjPropTermRoleHash->value(objPropertyExpression);
if (role) {
activeRoleSet->insert(role);
}
} else {
CDataPropertyExpression* dataPropertyExpression = dynamic_cast(expressionEntity);
if (dataPropertyExpression) {
CRole* role = mDataPropTermRoleHash->value(dataPropertyExpression);
if (role) {
activeRoleSet->insert(role);
}
}
}
}
}
}
}
}
LOG(INFO,"::Konclude::Reasoner::Preprocess::MappingUpdater",logTr("Found %1 active classes, %2 active object/data properties, %3 active individuals.").arg(activeClassConceptSet->count()).arg(activeRoleSet->count()).arg(activeIndividualSet->count()),this);
return true;
}
bool CMappingUpdaterPreProcess::collectActiveOntologyItems() {
mUpdateConceptSet.insert(tbox->getTopConcept());
mUpdateConceptList.append(tbox->getTopConcept());
mUpdateConceptSet.insert(tbox->getBottomConcept());
mUpdateConceptList.append(tbox->getBottomConcept());
mUpdateRoleSet.insert(rbox->getTopObjectRole());
mUpdateRoleList.append(rbox->getTopObjectRole());
mUpdateRoleSet.insert(rbox->getBottomObjectRole());
mUpdateRoleList.append(rbox->getBottomObjectRole());
if (!mBuildConstructFlags->isRetractionUsed()) {
qint64 conCounts = mConceptVec->getItemCount();
for (qint64 i = 2; i < conCounts; ++i) {
CConcept *concept = mConceptVec->getLocalData(i);
if (concept) {
if (concept->hasClassName()) {
if (!mUpdateConceptSet.contains(concept)) {
mUpdateConceptSet.insert(concept);
mUpdateConceptList.append(concept);
}
}
}
}
} else {
FOREACHIT (CDeclarationAxiomExpression* declAxiom, *mDeclarationAxiomSet) {
CExpressionEntity* entity = declAxiom->getEntity();
CClassExpression* classExp = dynamic_cast(entity);
if (classExp) {
CConcept* concept = mClassTermConceptHash->value(classExp,nullptr);
if (concept) {
if (!mUpdateConceptSet.contains(concept)) {
mUpdateConceptSet.insert(concept);
mUpdateConceptList.append(concept);
}
}
}
CObjectPropertyExpression* objPropExp = dynamic_cast(entity);
if (objPropExp) {
CRole* role = mObjPropTermRoleHash->value(objPropExp,nullptr);
if (role) {
if (!mUpdateRoleSet.contains(role)) {
mUpdateRoleSet.insert(role);
mUpdateRoleList.append(role);
}
}
}
//CIndividualTermExpression* indiExp = dynamic_cast(entity);
//if (indiExp) {
// CIndividual* individual = mIndiTermIndiHash->value(indiExp);
// if (individual) {
// if (!mUpdateIndividualSet.contains(individual)) {
// mUpdateIndividualSet.insert(individual);
// mUpdateIndividualList.append(individual);
// }
// }
//}
}
// consider all Abox individual, not only those which are referenced by definitions
// if an individual is removed from the KB, then there are no asserted concepts
cint64 indiCount = abox->getIndividualCount();
CIndividualVector* indiVec = abox->getIndividualVector(false);
if (indiVec) {
for (cint64 indiID = 0; indiID < indiCount; ++indiID) {
CIndividual* individual = indiVec->getData(indiID);
if (individual) {
for (CConceptAssertionLinker* conAssIt = individual->getAssertionConceptLinker(); conAssIt; conAssIt = conAssIt->getNext()) {
CConcept* concept = conAssIt->getData();
if (!mUpdateConceptSet.contains(concept)) {
mUpdateConceptSet.insert(concept);
mUpdateConceptList.append(concept);
}
}
}
}
}
FOREACHIT (CClassTermExpression* classTermExp, mClassTermClassAxiomHash->keys()) {
if (mClassTermClassAxiomHash->value(classTermExp) != nullptr) {
CConcept* concept = mClassTermConceptHash->value(classTermExp,nullptr);
if (concept) {
if (!mUpdateConceptSet.contains(concept)) {
mUpdateConceptSet.insert(concept);
mUpdateConceptList.append(concept);
}
}
}
}
FOREACHIT (CObjectPropertyTermExpression* objPropTermExp, mObjPropTermObjPropAxiomHash->keys()) {
if (mObjPropTermObjPropAxiomHash->value(objPropTermExp) != nullptr) {
CRole* role = mObjPropTermRoleHash->value(objPropTermExp,nullptr);
if (role) {
if (!mUpdateRoleSet.contains(role)) {
mUpdateRoleSet.insert(role);
mUpdateRoleList.append(role);
}
}
}
}
while (!mUpdateConceptList.isEmpty() || !mUpdateRoleList.isEmpty() || !mUpdateIndividualList.isEmpty()) {
while (!mUpdateConceptList.isEmpty()) {
CConcept* concept = mUpdateConceptList.takeFirst();
CSortedNegLinker* opLinkerIt = concept->getOperandList();
while (opLinkerIt) {
CConcept* opCon = opLinkerIt->getData();
if (!mUpdateConceptSet.contains(opCon)) {
mUpdateConceptSet.insert(opCon);
mUpdateConceptList.append(opCon);
}
opLinkerIt = opLinkerIt->getNext();
}
CRole* role = concept->getRole();
if (role && !mUpdateRoleSet.contains(role)) {
mUpdateRoleSet.insert(role);
mUpdateRoleList.append(role);
}
//CIndividual* individual = concept->getNominalIndividual();
//if (individual && !mUpdateIndividualSet.contains(individual)) {
// mUpdateIndividualSet.insert(individual);
// mUpdateIndividualList.append(individual);
//}
}
//while (!mUpdateIndividualList.isEmpty()) {
// CIndividual* individual = mUpdateIndividualList.takeFirst();
// for (CConceptAssertionLinker* conAssIt = individual->getAssertionConceptLinker(); conAssIt; conAssIt = conAssIt->getNext()) {
// CConcept* concept = conAssIt->getData();
// if (!mUpdateConceptSet.contains(concept)) {
// mUpdateConceptSet.insert(concept);
// mUpdateConceptList.append(concept);
// }
// }
// for (CRoleAssertionLinker* roleAssIt = individual->getAssertionRoleLinker(); roleAssIt; roleAssIt = roleAssIt->getNext()) {
// CRole* role = roleAssIt->getRole();
// if (!mUpdateRoleSet.contains(role)) {
// mUpdateRoleSet.insert(role);
// mUpdateRoleList.append(role);
// }
// CIndividual* individual2 = roleAssIt->getIndividual();
// if (!mUpdateIndividualSet.contains(individual2)) {
// mUpdateIndividualSet.insert(individual2);
// mUpdateIndividualList.append(individual2);
// }
// }
//}
while (!mUpdateRoleList.isEmpty()) {
CRole* role = mUpdateRoleList.takeFirst();
CSortedNegLinker* roleLinkerIt = role->getIndirectSuperRoleList();
while (roleLinkerIt) {
CRole* superRole = roleLinkerIt->getData();
if (!mUpdateRoleSet.contains(superRole)) {
mUpdateRoleSet.insert(superRole);
mUpdateRoleList.append(superRole);
}
roleLinkerIt = roleLinkerIt->getNext();
}
CSortedNegLinker* disRoleLinkerIt = role->getDisjointRoleList();
while (disRoleLinkerIt) {
CRole* disRole = disRoleLinkerIt->getData();
if (!mUpdateRoleSet.contains(disRole)) {
mUpdateRoleSet.insert(disRole);
mUpdateRoleList.append(disRole);
}
disRoleLinkerIt = disRoleLinkerIt->getNext();
}
CSortedNegLinker* domainConLinkerIt = role->getDomainConceptList();
while (domainConLinkerIt) {
CConcept* opCon = domainConLinkerIt->getData();
if (!mUpdateConceptSet.contains(opCon)) {
mUpdateConceptSet.insert(opCon);
mUpdateConceptList.append(opCon);
}
domainConLinkerIt = domainConLinkerIt->getNext();
}
CSortedNegLinker* rangeConLinkerIt = role->getRangeConceptList();
while (rangeConLinkerIt) {
CConcept* opCon = rangeConLinkerIt->getData();
if (!mUpdateConceptSet.contains(opCon)) {
mUpdateConceptSet.insert(opCon);
mUpdateConceptList.append(opCon);
}
rangeConLinkerIt = rangeConLinkerIt->getNext();
}
}
}
}
CBOXSET* activeClassConceptSet = tbox->getActiveClassConceptSet();
activeClassConceptSet->clear();
FOREACHIT (CConcept* concept, mUpdateConceptSet) {
if (concept->hasClassName()) {
activeClassConceptSet->insert(concept);
}
}
return true;
}
}; // end namespace Preprocess
}; // end namespace Reasoner
}; // end namespace Konclude