/*
* 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 "CClassAssertionQuery.h"
#include "Reasoner/Kernel/Task/CConsistenceTaskData.h"
#include "Reasoner/Kernel/Task/CSatisfiableCalculationTask.h"
namespace Konclude {
namespace Reasoner {
using namespace Kernel::Task;
namespace Query {
CClassAssertionQuery::CClassAssertionQuery(CConcreteOntology* ontology, CConfigurationBase* configuration, const QSet& individualSet, const QString& queryName)
: CConsistencePremisingQuery(ontology,configuration) {
mQueryName = queryName;
if (mQueryName.isEmpty()) {
mQueryName = QString("Get Concept Assertions");
}
mResult = nullptr;
mUseAbbreviatedIRIs = CConfigDataReader::readConfigBoolean(configuration,"Konclude.OWLlink.AbbreviatedIRIs",false);
mConsistencyCalcError = false;
mQueryConstructError = false;
mDeterministicAssertions = false;
mNondeterministicAssertions = false;
mIndividualSet = individualSet;
mCalcConfig = configuration;
}
CClassAssertionQuery::~CClassAssertionQuery() {
if (mResult) {
delete mResult;
}
delete mCalcConfig;
}
CQueryResult* CClassAssertionQuery::getQueryResult() {
return mResult;
}
CQueryResult *CClassAssertionQuery::constructResult(CConsistence* consistence) {
return constructAssertionResult(consistence);
}
bool CClassAssertionQuery::addIndividualResultData(cint64 indiID, CIndividualProcessNodeVector* indiNodeVec) {
CBOXSET* eqNonCanSet = ontology->getTBox()->getEquivalentConceptNonCandidateSet(false);
bool indiConAssertionAdded = false;
CIndividualProcessNode* baseIndiNode = indiNodeVec->getData(indiID);
CIndividualProcessNode* indiNode = baseIndiNode;
if (indiNode && indiNode->getNominalIndividual()) {
cint64 mergedIndiID = indiID;
bool nonDeterministicMerged = false;
while (mergedIndiID != indiNode->getMergedIntoIndividualNodeID()) {
mergedIndiID = indiNode->getMergedIntoIndividualNodeID();
CDependencyTrackPoint* mergedDepTrackPoint = indiNode->getMergedDependencyTrackPoint();
if (!mergedDepTrackPoint || mergedDepTrackPoint->getBranchingTag() > 0) {
nonDeterministicMerged = true;
}
indiNode = indiNodeVec->getData(mergedIndiID);
}
CReapplyConceptLabelSet* conLabelSet = indiNode->getReapplyConceptLabelSet(false);
if (conLabelSet) {
bool allNonDeterministic = nonDeterministicMerged;
QString indiName;
if (mUseAbbreviatedIRIs) {
indiName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(baseIndiNode->getNominalIndividual()->getIndividualNameLinker());
} else {
indiName = CIRIName::getRecentIRIName(baseIndiNode->getNominalIndividual()->getIndividualNameLinker());
}
for (CConceptDescriptor* conDesIt = conLabelSet->getAddingSortedConceptDescriptionLinker(); conDesIt; conDesIt = conDesIt->getNext()) {
CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint();
bool conNegation = conDesIt->isNegated();
CConcept* concept = conDesIt->getConcept();
if (mDeterministicAssertions && depTrackPoint && depTrackPoint->getBranchingTag() <= 0 && !allNonDeterministic || mNondeterministicAssertions && (allNonDeterministic || !depTrackPoint || depTrackPoint->getBranchingTag() > 0)) {
if (!conNegation && concept && concept->hasClassName()) {
QString conceptName;
if (mUseAbbreviatedIRIs) {
conceptName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(concept->getClassNameLinker());
} else {
conceptName = CIRIName::getRecentIRIName(concept->getClassNameLinker());
}
mResult->addIndividualConceptAssertion(indiName,conceptName);
indiConAssertionAdded = true;
}
}
if (mNondeterministicAssertions && concept->getOperatorCode() == CCEQCAND) {
CConcept* eqConcept = concept->getOperandList()->getData();
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept,&negation)) {
QString conceptName;
if (mUseAbbreviatedIRIs) {
conceptName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(eqConcept->getClassNameLinker());
} else {
conceptName = CIRIName::getRecentIRIName(eqConcept->getClassNameLinker());
}
mResult->addIndividualConceptAssertion(indiName,conceptName);
indiConAssertionAdded = true;
}
}
}
if (eqNonCanSet) {
for (CBOXSET::const_iterator it = eqNonCanSet->constBegin(), itEnd = eqNonCanSet->constEnd(); it != itEnd; ++it) {
CConcept* eqConcept(*it);
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept,&negation)) {
QString conceptName;
if (mUseAbbreviatedIRIs) {
conceptName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(eqConcept->getClassNameLinker());
} else {
conceptName = CIRIName::getRecentIRIName(eqConcept->getClassNameLinker());
}
mResult->addIndividualConceptAssertion(indiName,conceptName);
indiConAssertionAdded = true;
}
}
}
}
}
return indiConAssertionAdded;
}
CIndividualClassAssertionsResult *CClassAssertionQuery::constructAssertionResult(CConsistence* consistence) {
if (mResult) {
delete mResult;
mResult = 0;
}
if (consistence) {
mResult = new CIndividualClassAssertionsResult();
CConsistenceTaskData* consTaskData = (CConsistenceTaskData*)consistence->getConsistenceModelData();
if (consTaskData) {
CSatisfiableCalculationTask* detTask = consTaskData->getDeterministicSatisfiableTask();
CSatisfiableCalculationTask* nonDetTask = consTaskData->getCompletionGraphCachedSatisfiableTask();
if (detTask != nonDetTask) {
CProcessingDataBox* dataBox = nonDetTask->getProcessingDataBox();
if (dataBox) {
CIndividualProcessNodeVector* indiNodeVec = dataBox->getIndividualProcessNodeVector();
cint64 indiNodeMinIdx = indiNodeVec->getItemMinIndex();
if (mIndividualSet.isEmpty()) {
for (cint64 indiID = indiNodeMinIdx; indiID <= 0; ++indiID) {
addIndividualResultData(indiID,indiNodeVec);
}
} else {
for (QSet::const_iterator it = mIndividualSet.constBegin(), itEnd = mIndividualSet.constEnd(); it != itEnd; ++it) {
CIndividual* individual(*it);
cint64 indiID = individual->getIndividualID();
addIndividualResultData(-indiID,indiNodeVec);
}
}
}
}
}
}
return mResult;
}
QString CClassAssertionQuery::getQueryName() {
return mQueryName;
}
QString CClassAssertionQuery::getQueryString() {
return mQueryString;
}
bool CClassAssertionQuery::hasAnswer() {
return mResult != 0;
}
QString CClassAssertionQuery::getAnswerString() {
if (!mResult) {
return QString("Unknown Concept Assertions");
} else {
return mResult->getQueryResultString();
}
}
bool CClassAssertionQuery::hasError() {
return mConsistencyCalcError || mQueryConstructError || CQuery::hasError();
}
}; // end namespace Query
}; // end namespace Reasoner
}; // end namespace Konclude