/*
* 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 "CLexicalNormalisationPreProcess.h"
namespace Konclude {
namespace Reasoner {
namespace Preprocess {
CLexicalNormalisationPreProcess::CLexicalNormalisationPreProcess() {
mOntology = nullptr;
}
CLexicalNormalisationPreProcess::~CLexicalNormalisationPreProcess() {
}
void CLexicalNormalisationPreProcess::negateOperandConcepts(CConcept *concept, int firstNegationOperand) {
CSortedNegLinker *operands = concept->getOperandList();
int operand = 0;
while (operands) {
if (operand++ >= firstNegationOperand) {
operands->setNegated(!operands->isNegated());
}
operands = operands->getNext();
}
}
CConcreteOntology *CLexicalNormalisationPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) {
bool skipForELOntologies = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Preprocessing.LexicalNormalization.SkipForELFragment",true);
bool nonELConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNonELConstructUsed();
mOntology = nullptr;
if (nonELConstructsUsed || !skipForELOntologies) {
mOntology = ontology;
CTBox* tbox = ontology->getDataBoxes()->getTBox();
CABox *abox = ontology->getDataBoxes()->getABox();
CRBox *rbox = ontology->getDataBoxes()->getRBox();
CMBox *mbox = ontology->getDataBoxes()->getMBox();
mBoxMemMan = CContext::getMemoryAllocationManager(ontology->getDataBoxes()->getBoxContext());
CNominalSchemaTemplateVector* nomSchTemplVector = mbox->getNominalSchemaTemplateVector(false);
concepts = tbox->getConceptVector();
qint64 conceptCount = concepts->getItemCount();
roles = rbox->getRoleVector();
qint64 roleCount = rbox->getRoleCount();
for (qint64 i = 0; i < conceptCount; ++i) {
CConcept *concept = concepts->getLocalData(i);
if (concept) {
qint64 cOpCode = concept->getDefinitionOperatorTag();
if (cOpCode == CCOR) {
concept->setMappingNegation(true);
concept->setOperatorTag(CCAND);
negateOperandConcepts(concept,0);
} else if (cOpCode == CCSOME) {
concept->setMappingNegation(true);
concept->setOperatorTag(CCALL);
negateOperandConcepts(concept,0);
}
}
}
topConcept = concepts->getData(1);
for (qint64 i = 0; i < conceptCount; ++i) {
CConcept *concept = concepts->getLocalData(i);
if (concept) {
CSortedNegLinker *operands = concept->getOperandList();
while (operands) {
CConcept *opConcept = operands->getData();
if (opConcept->hasMappingNegation()) {
operands->setNegated(!operands->isNegated());
}
if (opConcept->getDefinitionOperatorTag() == CCBOTTOM) {
operands->setData(topConcept);
operands->setNegated(!operands->isNegated());
}
if (nomSchTemplVector) {
if (opConcept->getOperatorCode() == CCNOMTEMPLREF || opConcept->getOperatorCode() == CCPBINDGROUND || opConcept->getOperatorCode() == CCVARBINDGROUND) {
CNominalSchemaTemplate* nsTemplate = nomSchTemplVector->getData(opConcept->getParameter());
if (nsTemplate) {
if (nsTemplate->getTemplateConcept()->hasMappingNegation()) {
operands->setNegated(!operands->isNegated());
}
}
}
}
operands = operands->getNext();
}
}
}
for (qint64 i = 0; i < roleCount; ++i) {
CRole *role = roles->getLocalData(i);
if (role) {
CSortedNegLinker *domainConIt = role->getDomainConceptList();
while (domainConIt) {
CConcept *domainConcept = domainConIt->getData();
if (domainConcept->hasMappingNegation()) {
domainConIt->setNegated(!domainConIt->isNegated());
}
domainConIt = domainConIt->getNext();
}
CSortedNegLinker *rangeConIt = role->getRangeConceptList();
while (rangeConIt) {
CConcept *rangeConcept = rangeConIt->getData();
if (rangeConcept->hasMappingNegation()) {
rangeConIt->setNegated(!rangeConIt->isNegated());
}
rangeConIt = rangeConIt->getNext();
}
}
}
if (abox) {
individuals = abox->getIndividualVector();
qint64 individualCount = abox->getIndividualCount();
for (qint64 i = 0; i < individualCount; ++i) {
CIndividual *indi = individuals->getLocalData(i);
if (indi) {
CConceptAssertionLinker* assertionConLinker = indi->getAssertionConceptLinker();
while (assertionConLinker) {
if (assertionConLinker->getData()->hasMappingNegation()) {
assertionConLinker->setNegation(!assertionConLinker->isNegated());
}
assertionConLinker = assertionConLinker->getNext();
}
}
}
}
replacementHash = new QHash();
processedSet = new QSet();
conceptReplaceHash = new QHash >();
processingList = new QList();
for (qint64 i = 0; i < conceptCount; ++i) {
CConcept *concept = concepts->getLocalData(i);
if (concept) {
if (!processedSet->contains(concept)) {
//QString iriClassNameString2 = CIRIName::getRecentIRIName(concept->getClassNameLinker());
//if (iriClassNameString2 == "http://www.owllink.org/testsuite/particle-D#Proton") {
// bool bug = true;
//}
addNormalizeConcept(concept);
processedSet->insert(concept);
normalizeListedConcepts();
}
}
}
for (qint64 i = 0; i < roleCount; ++i) {
CRole *role = roles->getLocalData(i);
if (role) {
CSortedNegLinker *domainConIt = role->getDomainConceptList();
bool domainModified = false;
while (domainConIt) {
CConcept *domainConcept = domainConIt->getData();
if (conceptReplaceHash->contains(domainConcept)) {
QPair negRepConcept(conceptReplaceHash->value(domainConcept));
domainConcept = negRepConcept.second;
if (negRepConcept.first) {
domainConIt->setNegated(!domainConIt->isNegated());
}
domainConIt->setData(domainConcept);
domainModified = true;
}
domainConIt = domainConIt->getNext();
}
if (domainModified) {
domainConIt = role->getDomainConceptList();
domainConIt->resortLinkerData();
}
CSortedNegLinker *rangeConIt = role->getRangeConceptList();
bool rangeModified = false;
while (rangeConIt) {
CConcept *rangeConcept = rangeConIt->getData();
if (conceptReplaceHash->contains(rangeConcept)) {
QPair negRepConcept(conceptReplaceHash->value(rangeConcept));
rangeConcept = negRepConcept.second;
if (negRepConcept.first) {
rangeConIt->setNegated(!rangeConIt->isNegated());
}
rangeConIt->setData(rangeConcept);
domainModified = true;
}
rangeConIt = rangeConIt->getNext();
}
if (rangeModified) {
rangeConIt = role->getRangeConceptList();
rangeConIt->resortLinkerData();
}
}
}
if (abox) {
individuals = abox->getIndividualVector();
qint64 individualCount = abox->getIndividualCount();
for (qint64 i = 0; i < individualCount; ++i) {
CIndividual *indi = individuals->getLocalData(i);
if (indi) {
CConceptAssertionLinker* assertionConLinker = indi->getAssertionConceptLinker();
while (assertionConLinker) {
if (conceptReplaceHash->contains(assertionConLinker->getData())) {
QPair negRepConcept(conceptReplaceHash->value(assertionConLinker->getData()));
assertionConLinker->setData(negRepConcept.second);
if (negRepConcept.first) {
assertionConLinker->setNegation(!assertionConLinker->getNegation());
}
}
assertionConLinker = assertionConLinker->getNext();
}
}
}
}
delete replacementHash;
delete processedSet;
delete conceptReplaceHash;
delete processingList;
}
return ontology;
}
CConcreteOntology* CLexicalNormalisationPreProcess::continuePreprocessing() {
if (mOntology) {
}
return mOntology;
}
CSortedNegLinker* CLexicalNormalisationPreProcess::resortConceptLinkersByTagging(CSortedNegLinker* conceptLinkers) {
CSortedNegLinker* newConceptLinkers = nullptr;
while (conceptLinkers) {
CSortedNegLinker* tmpConceptLinker = conceptLinkers;
conceptLinkers = conceptLinkers->getNext();
tmpConceptLinker->setNext(nullptr);
if (!newConceptLinkers) {
newConceptLinkers = tmpConceptLinker;
} else {
newConceptLinkers = newConceptLinkers->insertSortedNextSorted(tmpConceptLinker);
}
}
return newConceptLinkers;
}
void CLexicalNormalisationPreProcess::addNormalizeConcept(CConcept *concept) {
processingList->prepend(concept);
}
void CLexicalNormalisationPreProcess::normalizeListedConcepts() {
while (!processingList->isEmpty()) {
CConcept* concept = processingList->first();
cint64 conceptTag = concept->getConceptTag();
bool isLocal = concepts->hasLocalData(conceptTag);
bool conceptNormalizationAdded = false;
CSortedNegLinker* opLinkerIt = concept->getOperandList();
if (isLocal) {
while (opLinkerIt) {
CConcept* opConcept = concepts->getData(opLinkerIt->getData()->getConceptTag());
if (!processedSet->contains(opConcept)) {
conceptNormalizationAdded = true;
addNormalizeConcept(opConcept);
processedSet->insert(opConcept);
}
opLinkerIt = opLinkerIt->getNext();
}
}
if (!conceptNormalizationAdded) {
processingList->removeFirst();
normalizeConcept(concept,isLocal);
}
}
}
void CLexicalNormalisationPreProcess::normalizeConcept(CConcept *concept, bool isLocal) {
CSortedNegLinker *opList = 0;
cint64 conceptTag = concept->getConceptTag();
bool implicTriggers = concept->getOperatorCode() == CCIMPL || concept->getOperatorCode() == CCIMPLALL;
bool nonReplace = false;
if (implicTriggers) {
nonReplace = true;
}
if (isLocal) {
CSortedNegLinker *conceptAddList = 0;
CSortedNegLinker *lastOpList = 0;
bool opConTagsModified = false;
opList = concept->getOperandList();
while (opList) {
CConcept *opConcept = concepts->getData(opList->getData()->getConceptTag());
if (!nonReplace && conceptReplaceHash->contains(opConcept)) {
QPair negRepConcept(conceptReplaceHash->value(opConcept));
opConcept = negRepConcept.second;
if (negRepConcept.first) {
opList->setNegated(!opList->isNegated());
}
opList->setData(opConcept);
opConTagsModified = true;
}
bool removeThisOp = false;
cint64 opCode = concept->getOperatorCode();
if (opCode == CCAND) {
cint64 operandOpCode = opConcept->getOperatorCode();
if ((operandOpCode == CCAND) && !opList->isNegated()) {
// remove concept from operand list and copy operand concepts from removed concept to this concept as operands
CSortedNegLinker *opOpList = opConcept->getOperandList();
while (opOpList) {
concept->incOperandCount();
conceptAddList = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mBoxMemMan)->init(opOpList->getData(),opOpList->isNegated())->insertSortedNextSorted(conceptAddList);
opOpList = opOpList->getNext();
}
removeThisOp = true;
} else if (opConcept->getDefinitionOperatorTag() == CCTOP && !opList->isNegated()) {
removeThisOp = true;
}
}
if (removeThisOp) {
concept->incOperandCount(-1);
if (!lastOpList) {
concept->setOperandList(opList->getNext());
opList = opList->getNext();
} else {
opList = opList->getNext();
lastOpList->removeNext();
}
} else {
lastOpList = opList;
opList = opList->getNext();
}
}
if (conceptAddList) {
concept->setOperandList(conceptAddList->insertSortedNextSorted(concept->getOperandList()));
}
if (opConTagsModified) {
concept->setOperandList(resortConceptLinkersByTagging(concept->getOperandList()));
}
}
bool isClash = false;
CSortedNegLinker *lastOpList = 0;
opList = concept->getOperandList();
while (opList) {
CConcept *opConcept = concepts->getData(opList->getData()->getConceptTag());
if (isLocal) {
if (!nonReplace && conceptReplaceHash->contains(opConcept)) {
QPair negRepConcept(conceptReplaceHash->value(opConcept));
opConcept = negRepConcept.second;
if (negRepConcept.first) {
opList->setNegated(!opList->isNegated());
}
opList->setData(opConcept);
}
}
qint64 opCCode = opConcept->getDefinitionOperatorTag();
if (concept->getProcessingOperatorTag() == CCAND && opCCode == CCTOP && opList->isNegated()) {
isClash = true;
}
if (concept->getProcessingOperatorTag() == CCSOME && opCCode == CCTOP && opList->isNegated()) {
isClash = true;
}
if (concept->getProcessingOperatorTag() == CCATLEAST && opCCode == CCTOP && opList->isNegated()) {
isClash = true;
}
if (concept->getProcessingOperatorTag() == CCAND && lastOpList && lastOpList->getData()->getConceptTag() == opList->getData()->getConceptTag()) {
if (lastOpList->isNegated() != opList->isNegated()) {
isClash = true;
}
}
lastOpList = opList;
opList = opList->getNext();
}
if (isClash) {
conceptReplaceHash->insert(concept,QPair(true,topConcept));
} else {
CConceptUnambiguousHasher conUnHasher(getConceptHasher(concept));
if (!replacementHash->contains(conUnHasher)) {
replacementHash->insert(conUnHasher,concept);
} else {
conceptReplaceHash->insert(concept,QPair(false,replacementHash->value(conUnHasher)));
}
}
}
CConceptUnambiguousHasher CLexicalNormalisationPreProcess::getConceptHasher(CConcept *concept) {
cint64 opCode = concept->getOperatorCode();
CConceptOperator* conOperator = concept->getConceptOperator();
if (opCode == CCATOM || opCode == CCSUB || opCode == CCEQ || opCode == CCDATATYPE || opCode == CCDATALITERAL || opCode == CCDATARESTRICTION || conOperator->hasPartialOperatorCodeFlag(CConceptOperator::CCFS_TRIG_TYPE)) {
return CConceptUnambiguousHasher(concept,true);
} else {
return CConceptUnambiguousHasher(concept,false);
}
}
}; // end namespace Preprocess
}; // end namespace Reasoner
}; // end namespace Konclude