/*
* 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 "CDeterministicNondeterministicIndividualsQuery.h"
#include "Reasoner/Kernel/Task/CConsistenceTaskData.h"
#include "Reasoner/Kernel/Task/CSatisfiableCalculationTask.h"
namespace Konclude {
namespace Reasoner {
using namespace Kernel::Task;
namespace Query {
CDeterministicNondeterministicIndividualsQuery::CDeterministicNondeterministicIndividualsQuery(CConcreteOntology* ontology, CConfigurationBase* configuration, const QSet& individualSet, const QString& queryName)
: CRealizationPremisingQuery(ontology,configuration) {
mQueryName = queryName;
mResult = nullptr;
mUseAbbreviatedIRIs = CConfigDataReader::readConfigBoolean(configuration,"Konclude.OWLlink.AbbreviatedIRIs",false);
mConsistencyCalcError = false;
mQueryConstructError = false;
mCalcConfig = configuration;
mIndividualSet = individualSet;
mDeterministicIndividuals = false;
mRequiresConceptRealisation = true;
mRequiresSameIndividualRealisation = true;
}
CDeterministicNondeterministicIndividualsQuery::~CDeterministicNondeterministicIndividualsQuery() {
if (mResult) {
delete mResult;
}
delete mCalcConfig;
}
CQueryResult* CDeterministicNondeterministicIndividualsQuery::getQueryResult() {
return mResult;
}
CQueryResult *CDeterministicNondeterministicIndividualsQuery::constructResult(CRealization* realization) {
return constructIndividualsResult(realization);
}
bool CDeterministicNondeterministicIndividualsQuery::addIndividualResultData(CIndividual* indi, CIndividualProcessNodeVector* indiNodeVec, QSet >* possAssSet) {
cint64 indiID = -indi->getIndividualID();
CBOXSET* eqNonCanSet = mOntology->getTBox()->getEquivalentConceptNonCandidateSet(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) {
for (CConceptDescriptor* conDesIt = conLabelSet->getAddingSortedConceptDescriptionLinker(); conDesIt; conDesIt = conDesIt->getNext()) {
CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint();
CConcept* concept = conDesIt->getConcept();
bool conNegation = conDesIt->isNegated();
if (nonDeterministicMerged || !depTrackPoint || depTrackPoint->getBranchingTag() > 0) {
if (!conNegation && concept && concept->hasClassName()) {
possAssSet->insert( QPair(indi,concept) );
}
}
if (concept->getOperatorCode() == CCEQCAND) {
CConcept* eqConcept = concept->getOperandList()->getData();
bool negation = false;
if (!conLabelSet->containsConcept(eqConcept,negation)) {
possAssSet->insert( QPair(indi,eqConcept) );
}
}
}
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)) {
possAssSet->insert( QPair(indi,eqConcept) );
}
}
}
}
return true;
}
return false;
}
CIndividualsResult *CDeterministicNondeterministicIndividualsQuery::constructIndividualsResult(CRealization* realization) {
if (mResult) {
delete mResult;
mResult = 0;
}
CConsistence* consistence = mOntology->getConsistence();
if (consistence && realization) {
mResult = new CIndividualsResult();
CConceptRealization* conRealisation = realization->getConceptRealization();
CPossibleAssertionsCollectionSet* possAssCollSet = conRealisation->getPossibleAssertionCollectionSet();
QSet< QPair > possAssSet;
QSet< QPair > knownAssSet;
CIndividualVector* indiVec = mOntology->getABox()->getIndividualVector();
cint64 indiCount = indiVec->getItemCount();
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 indiNodeCount = indiNodeVec->getItemCount();
if (mIndividualSet.isEmpty()) {
if (possAssCollSet) {
for (CPossibleAssertionsCollectionSet::const_iterator it = possAssCollSet->constBegin(), itEnd = possAssCollSet->constEnd(); it != itEnd; ++it) {
const QPair& possAssPair(*it);
possAssSet.insert( QPair(possAssPair.first,possAssPair.second) );
}
}
for (cint64 indiID = 0; indiID < indiCount; ++indiID) {
CIndividual* individual = indiVec->getData(indiID);
if (individual) {
addIndividualResultData(individual,indiNodeVec,&possAssSet);
CIndividualConceptAssertionSetCollector indiConAssColl(individual,&knownAssSet);
conRealisation->visitAllTypes(individual,&indiConAssColl);
}
}
} else {
if (possAssCollSet) {
for (CPossibleAssertionsCollectionSet::const_iterator it = possAssCollSet->constBegin(), itEnd = possAssCollSet->constEnd(); it != itEnd; ++it) {
const QPair& possAssPair(*it);
CIndividual* individual(possAssPair.first);
if (mIndividualSet.contains(individual)) {
possAssSet.insert( QPair(possAssPair.first,possAssPair.second) );
}
}
}
for (QSet::const_iterator it = mIndividualSet.constBegin(), itEnd = mIndividualSet.constEnd(); it != itEnd; ++it) {
CIndividual* individual(*it);
addIndividualResultData(individual,indiNodeVec,&possAssSet);
CIndividualConceptAssertionSetCollector indiConAssColl(individual,&knownAssSet);
conRealisation->visitAllTypes(individual,&indiConAssColl);
}
}
}
}
}
QSet nonDetIndiSet;
for (QSet< QPair >::const_iterator it = possAssSet.constBegin(), itEnd = possAssSet.constEnd(); it != itEnd; ++it) {
const QPair& indiConPair(*it);
if (!knownAssSet.contains(indiConPair)) {
CIndividual* indi = indiConPair.first;
nonDetIndiSet.insert(indi);
}
}
if (mIndividualSet.isEmpty()) {
for (cint64 indiID = 0; indiID < indiCount; ++indiID) {
CIndividual* individual = indiVec->getData(indiID);
if (individual) {
bool addIndiToResult = false;
if (mDeterministicIndividuals && !nonDetIndiSet.contains(individual)) {
addIndiToResult = true;
} else if (!mDeterministicIndividuals && nonDetIndiSet.contains(individual)) {
addIndiToResult = true;
}
if (addIndiToResult) {
QString indiName;
if (mUseAbbreviatedIRIs) {
indiName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(individual->getIndividualNameLinker());
} else {
indiName = CIRIName::getRecentIRIName(individual->getIndividualNameLinker());
}
mResult->addIndividual(indiName);
}
}
}
} else {
for (QSet::const_iterator it = mIndividualSet.constBegin(), itEnd = mIndividualSet.constEnd(); it != itEnd; ++it) {
CIndividual* individual(*it);
bool addIndiToResult = false;
if (mDeterministicIndividuals && !nonDetIndiSet.contains(individual)) {
addIndiToResult = true;
} else if (!mDeterministicIndividuals && nonDetIndiSet.contains(individual)) {
addIndiToResult = true;
}
if (addIndiToResult) {
QString indiName;
if (mUseAbbreviatedIRIs) {
indiName = CAbbreviatedIRIName::getRecentAbbreviatedPrefixWithAbbreviatedIRIName(individual->getIndividualNameLinker());
} else {
indiName = CIRIName::getRecentIRIName(individual->getIndividualNameLinker());
}
mResult->addIndividual(indiName);
}
}
}
}
return mResult;
}
QString CDeterministicNondeterministicIndividualsQuery::getQueryName() {
return mQueryName;
}
QString CDeterministicNondeterministicIndividualsQuery::getQueryString() {
return mQueryString;
}
bool CDeterministicNondeterministicIndividualsQuery::hasAnswer() {
return mResult != 0;
}
QString CDeterministicNondeterministicIndividualsQuery::getAnswerString() {
if (!mResult) {
return QString("Unknown Individuals");
} else {
return mResult->getQueryResultString();
}
}
bool CDeterministicNondeterministicIndividualsQuery::hasError() {
return mConsistencyCalcError || mQueryConstructError || CQuery::hasError();
}
}; // end namespace Query
}; // end namespace Reasoner
}; // end namespace Konclude