/* * 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 "CBranchTriggerPreProcess.h" namespace Konclude { namespace Reasoner { namespace Preprocess { CBranchTriggerPreProcess::CBranchTriggerPreProcess() { mOnto = nullptr; mLastConceptId = 0; mConfLocalizeRolesToGetTrigger = false; } CBranchTriggerPreProcess::~CBranchTriggerPreProcess() { } CConcreteOntology *CBranchTriggerPreProcess::preprocess(CConcreteOntology *ontology, CPreProcessContext* context) { bool skipForELOntologies = CConfigDataReader::readConfigBoolean(context->getConfiguration(),"Konclude.Calculation.Preprocessing.BranchTriggerExtraction.SkipForELFragment",true); bool nonELConstructsUsed = ontology->getDataBoxes()->getExpressionDataBoxMapping()->getBuildConstructFlags()->isNonELConstructUsed(); mOnto = nullptr; mLastConceptId = 0; if (nonELConstructsUsed || !skipForELOntologies) { CMBox *mBox = ontology->getDataBoxes()->getMBox(); CTBox *tBox = ontology->getDataBoxes()->getTBox(); CRBox *rBox = ontology->getDataBoxes()->getRBox(); CABox *aBox = ontology->getDataBoxes()->getABox(); mConceptVec = tBox->getConceptVector(); mRoleVector = rBox->getRoleVector(); CBranchingTriggerVector* branchTriggVec = mBox->getBranchingTriggerVector(); CRoleVector *roles = rBox->getRoleVector(); CConcept *topConcept = mConceptVec->getLocalData(1); mMemMan = ontology->getDataBoxes()->getBoxContext()->getMemoryAllocationManager(); mOnto = ontology; mTBox = tBox; mRBox = rBox; mRoleDomainTriggerConceptHash = nullptr; mStatConceptBranchTriggers = 0; mStatRoleBranchTriggers = 0; mStatBranchTriggers = 0; createBranchingTriggers(); LOG(INFO,"::Konclude::Reasoner::Preprocess::BranchTriggerExtractor",logTr("Extracted %1 concept and %2 role branch triggers for %3 concepts.").arg(mStatConceptBranchTriggers).arg(mStatRoleBranchTriggers).arg(mStatBranchTriggers),this); } return ontology; } CConcreteOntology* CBranchTriggerPreProcess::continuePreprocessing() { if (mOnto) { createBranchingTriggers(); } return mOnto; } CBranchTriggerPreProcess* CBranchTriggerPreProcess::createBranchingTriggers() { CTBox *tBox = mOnto->getDataBoxes()->getTBox(); CMBox *mBox = mOnto->getDataBoxes()->getMBox(); CBranchingTriggerVector* branchTriggVec = mBox->getBranchingTriggerVector(); cint64 conCount = tBox->getConceptCount(); for (cint64 conIdx = mLastConceptId; conIdx < conCount; ++conIdx) { CConcept* concept = mConceptVec->getLocalData(conIdx); if (concept) { cint64 conOpCode = concept->getOperatorCode(); cint64 opCount = concept->getOperandCount(); CConceptRoleBranchingTrigger* branchingTriggers = nullptr; bool negConTriggers = false; if (!branchTriggVec->hasData(conIdx)) { if (opCount > 1) { if (conOpCode == CCAND || conOpCode == CCEQ) { negConTriggers = true; branchingTriggers = createBranchingTriggers(concept, negConTriggers); } else if (conOpCode == CCOR) { branchingTriggers = createBranchingTriggers(concept, negConTriggers); } } if (branchingTriggers) { ++mStatBranchTriggers; branchTriggVec->setData(conIdx, branchingTriggers); } } } } mLastConceptId = conCount; return this; } CConceptRoleBranchingTrigger *CBranchTriggerPreProcess::createBranchingTriggers(CConcept* concept, bool negated) { typedef QPair TConNegPair; CConceptRoleBranchingTrigger* branchingTriggerList = nullptr; QSet branchingTriggerSet; QList disjList; QList disjInitList; disjInitList.append(TConNegPair(concept,negated)); while (!disjInitList.isEmpty()) { TConNegPair disConNegPair(disjInitList.takeFirst()); CConcept *disCon = disConNegPair.first; bool disNeg = disConNegPair.second; qint64 disConOpCode = disCon->getOperatorCode(); if (!disNeg && (disConOpCode == CCOR) || disNeg && (disConOpCode == CCAND || disConOpCode == CCEQ)) { CSortedNegLinker *splitOrOpIt = disCon->getOperandList(); while (splitOrOpIt) { CConcept *splitCon = splitOrOpIt->getData(); bool splitConNeg = splitOrOpIt->isNegated(); disjInitList.append(TConNegPair(splitCon,splitConNeg^disNeg)); splitOrOpIt = splitOrOpIt->getNext(); } } else { disjList.append(TConNegPair(disCon,disNeg)); } } while (!disjList.isEmpty()) { TConNegPair disConNegPair(disjList.takeFirst()); CConcept *disCon = disConNegPair.first; bool disNeg = disConNegPair.second; cint64 conOpCount = disCon->getOperandCount(); CConceptRoleBranchingTrigger* branchingTrigger = nullptr; qint64 disConOpCode = disCon->getDefinitionOperatorTag(); if (disNeg && (disConOpCode == CCSUB || disConOpCode == CCATOM)) { if (!branchingTriggerSet.contains(TConNegPair(disCon,!disNeg))) { branchingTriggerSet.insert(TConNegPair(disCon,!disNeg)); branchingTrigger = CObjectAllocator< CConceptRoleBranchingTrigger >::allocateAndConstruct(mMemMan); branchingTrigger->initConceptBranchingTrigger(disCon,!disNeg); ++mStatConceptBranchTriggers; } } else if (disConOpCode == CCALL && !disNeg || disConOpCode == CCSOME && disNeg || disConOpCode == CCATMOST && !disNeg || disConOpCode == CCATLEAST && disNeg && conOpCount > 0) { CRole* role = disCon->getRole(); CConcept* triggerDomConcept = getRoleDomainTriggerConcept(role, false); bool roleLocated = mRoleVector->hasLocalData(role->getRoleTag()); if (triggerDomConcept || roleLocated || mConfLocalizeRolesToGetTrigger) { CRole* locatedRole = role; if (!roleLocated) { roleLocated = true; locatedRole = CConceptRoleIndividualLocator::getLocatedRole(role, mOnto); } if (!triggerDomConcept) { triggerDomConcept = getRoleDomainTriggerConcept(locatedRole, true); } if (!branchingTriggerSet.contains(TConNegPair(triggerDomConcept, false))) { branchingTriggerSet.insert(TConNegPair(triggerDomConcept, false)); branchingTrigger = CObjectAllocator< CConceptRoleBranchingTrigger >::allocateAndConstruct(mMemMan); branchingTrigger->initConceptBranchingTrigger(triggerDomConcept, false); ++mStatRoleBranchTriggers; } } } if (branchingTrigger) { branchingTriggerList = branchingTrigger->append(branchingTriggerList); } } return branchingTriggerList; } bool CBranchTriggerPreProcess::addRoleDomainConcept(CRole* role, CConcept* addedConcept, bool negated) { CSortedNegLinker* newBaseOpCon = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(mMemMan); newBaseOpCon->init(addedConcept,negated,role->getDomainConceptList()); role->setDomainConceptList(newBaseOpCon); return true; } CConcept* CBranchTriggerPreProcess::getRoleDomainTriggerConcept(CRole* role, bool createIfNotExists) { if (!mRoleDomainTriggerConceptHash) { mRoleDomainTriggerConceptHash = mTBox->getRoleDomainTriggerConceptHash(true); } CConcept*& triggerConcept = (*mRoleDomainTriggerConceptHash)[role]; if (!triggerConcept && createIfNotExists) { triggerConcept = createTriggerConcept(); addRoleDomainConcept(role,triggerConcept,false); } return triggerConcept; } CConcept* CBranchTriggerPreProcess::createTriggerConcept() { CConcept* triggerConcept = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan); triggerConcept->initConcept(); cint64 nextConTag = mConceptVec->getItemCount(); triggerConcept->initTag(nextConTag); triggerConcept->setOperatorCode(CCIMPLTRIG); mConceptVec->setLocalData(nextConTag,triggerConcept); return triggerConcept; } }; // end namespace Preprocess }; // end namespace Reasoner }; // end namespace Konclude