/*
* 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 "COptimizedClassExtractedSaturationSubsumptionClassifierThread.h"
namespace Konclude {
namespace Reasoner {
namespace Classifier {
COptimizedClassExtractedSaturationSubsumptionClassifierThread::COptimizedClassExtractedSaturationSubsumptionClassifierThread(CReasonerManager *reasonerManager)
: CSubsumptionClassifierThread(reasonerManager), CLogIdentifier("::Konclude::Reasoner::Kernel::Classifier::OptimizedClassExtractedSaturationSubsumptionClassifierThread",this) {
mClassificationCount = 0;
satTestedCount = 0;
totalToTestCount = 0;
}
COptimizedClassExtractedSaturationSubsumptionClassifierThread::~COptimizedClassExtractedSaturationSubsumptionClassifierThread() {
}
CTaxonomy *COptimizedClassExtractedSaturationSubsumptionClassifierThread::createEmptyTaxonomyForOntology(CConcreteOntology *ontology, CConfigurationBase *config) {
CTBox *tBox = ontology->getTBox();
CConceptVector *conVec = tBox->getConceptVector();
CConcept *topConcept = conVec->getData(1);
CConcept *bottomConcept = conVec->getData(0);
CPartialPruningTaxonomy *tax = new CPartialPruningTaxonomy(topConcept,bottomConcept);
return tax->readConfig(config);
}
void COptimizedClassExtractedSaturationSubsumptionClassifierThread::readCalculationConfig(CCalculationConfigurationExtension *config) {
mTransitiveReductionAddAllPredecessors = CConfigDataReader::readConfigBoolean(config,"Konclude.Calculation.Classification.TransitiveReduction.AddAllPredecessors",true);
}
CSubsumptionClassifierThread *COptimizedClassExtractedSaturationSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) {
CTaxonomy *taxonomy = createEmptyTaxonomyForOntology(ontology,config);
COptimizedClassExtractedSaturationOntologyClassificationItem *ontClassItem = new COptimizedClassExtractedSaturationOntologyClassificationItem(config,statistics);
ontClassItem->initTaxonomyConcepts(ontology,taxonomy);
ontItemList.append(ontClassItem);
processingOntItemList.append(ontClassItem);
ontItemHash.insert(ontology,ontClassItem);
CCalculationConfigurationExtension* calcConfig = ontClassItem->getCalculationConfiguration();
readCalculationConfig(calcConfig);
if (CConfigDataReader::readConfigBoolean(ontClassItem->getCalculationConfiguration(),"Konclude.Calculation.Classification.IndividualDependenceTracking",true)) {
ontClassItem->setIndividualDependenceTrackingCollector(new CIndividualDependenceTrackingCollector());
}
CPartialPruningTaxonomy *parTax = dynamic_cast(taxonomy);
if (parTax) {
COntologyClassClassificationItem *ontClassItem = (COntologyClassClassificationItem*)ontItemHash.value(ontology);
parTax->createStatistics(ontClassItem->getClassifierStatistics());
}
readSubsumptionFromPrecomputedSaturation(ontClassItem);
if (satTestedCount == totalToTestCount) {
satTestedCount = 0;
totalToTestCount = 1;
classStartTime.start();
} else {
totalToTestCount += 1;
}
++mClassificationCount;
return this;
}
void COptimizedClassExtractedSaturationSubsumptionClassifierThread::readSubsumptionFromPrecomputedSaturation(COptimizedClassExtractedSaturationOntologyClassificationItem* ontClassItem) {
CTBox *tBox = ontClassItem->getOntology()->getDataBoxes()->getTBox();
CConcreteOntology *onto = ontClassItem->getOntology();
CConcept *topConcept = onto->getDataBoxes()->getTopConcept();
CConcept *bottomConcept = onto->getDataBoxes()->getBottomConcept();
CConceptVector* conVec = tBox->getConceptVector();
LOG(INFO,getLogDomain(),logTr("Read subsumers from precomputed saturation for ontology '%1'.").arg(ontClassItem->getOntology()->getTerminologyName()),getLogObject());
QHash* conceptSatItemHash = ontClassItem->getClassSatisfiableTestItemHash();
QList* satTestItemContainer = ontClassItem->getClassSatisfiableTestItemList();
COptimizedClassExtractedSaturationSatisfiableTestingItem* topItem = ontClassItem->getClassSatisfiableTestItem(topConcept,true);
COptimizedClassExtractedSaturationSatisfiableTestingItem* bottomItem = ontClassItem->getClassSatisfiableTestItem(bottomConcept,true);
ontClassItem->initTopBottomSatisfiableTestingItems(topItem,bottomItem);
CTaxonomy *tax = ontClassItem->getTaxonomy();
CHierarchyNode* bottomHierNode = tax->getBottomHierarchyNode();
CPrecomputedSaturationSubsumerExtractor precSatSubsumerExtractor(onto);
QList extClassItemList;
CBOXSET *conceptHash = tBox->getActiveClassConceptSet(false);
if (conceptHash) {
cint64 conCount = conVec->getItemCount();
for (cint64 conIdx = 1; conIdx < conCount; ++conIdx) {
CConcept* concept = conVec->getData(conIdx);
if (concept) {
if (concept->hasClassName() && conceptHash->contains(concept)) {
bool unsatFlag = false;
bool insuffFlag = false;
bool incProcFlag = false;
precSatSubsumerExtractor.getConceptFlags(concept,&unsatFlag,&insuffFlag,&incProcFlag);
if (unsatFlag) {
bottomHierNode->addEquivalentConcept(concept);
} else {
CConceptProcessData* conProcData = (CConceptProcessData*)concept->getConceptData();
CConceptSaturationReferenceLinkingData* conRefSatLinking = (CConceptSaturationReferenceLinkingData*)conProcData->getConceptReferenceLinking();
if (!conRefSatLinking) {
conRefSatLinking = new CConceptSaturationReferenceLinkingData();
conProcData->setConceptReferenceLinking(conRefSatLinking);
}
COptimizedClassExtractedSaturationSatisfiableTestingItem* classItem = ontClassItem->getClassSatisfiableTestItem(concept,true);
conRefSatLinking->setClassifierReferenceLinkingData(classItem);
extClassItemList.append(classItem);
}
}
}
}
}
for (QList::const_iterator it = extClassItemList.constBegin(), itEnd = extClassItemList.constEnd(); it != itEnd; ++it) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* classExtTestItem(*it);
CConcept* concept = classExtTestItem->getTestingConcept();
cint64 subsumerCount = precSatSubsumerExtractor.getSubsumerCount(concept);
classExtTestItem->setExtractionSubsumerCount(subsumerCount);
}
ontClassItem->decCurrentCalculatingCount();
++satTestedCount;
}
COptimizedClassExtractedSaturationSatisfiableTestingItem* getItemForConcept(CConcept* concept) {
CConceptProcessData* conProcData = (CConceptProcessData*)concept->getConceptData();
if (conProcData) {
CConceptSaturationReferenceLinkingData* conRefSatLinking = (CConceptSaturationReferenceLinkingData*)conProcData->getConceptReferenceLinking();
if (conRefSatLinking) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* classItem = (COptimizedClassExtractedSaturationSatisfiableTestingItem*)conRefSatLinking->getClassifierReferenceLinkingData();
return classItem;
}
}
return nullptr;
}
bool isDirectSubsumer(CConcept* concept, CConcept* subsumerConcept) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* classItem = getItemForConcept(concept);;
if (classItem) {
cint64 conSubsumerCount = classItem->getExtractionSubsumerCount();
COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumerClassItem = getItemForConcept(subsumerConcept);
if (subsumerClassItem) {
cint64 subsumerConSubsumerCount = subsumerClassItem->getExtractionSubsumerCount();
if (subsumerConSubsumerCount == conSubsumerCount-1) {
return true;
}
}
}
return false;
}
QString COptimizedClassExtractedSaturationSubsumptionClassifierThread::getStatusString() {
statUpdateMutex.lock();
QString string = statusString;
string.detach();
statUpdateMutex.unlock();
return string;
}
CClassificationProgress* COptimizedClassExtractedSaturationSubsumptionClassifierThread::getClassificationProgress() {
if (satTestedCount != totalToTestCount) {
cint64 testedClasses = satTestedCount;
cint64 totalClasses = totalToTestCount;
cint64 elapsedTime = classStartTime.elapsed();
double remainingMilliSeconds = 0.;
double progessPercent = 0.;
if (elapsedTime <= 0 && testedClasses > 0) {
remainingMilliSeconds = 0.;
} else {
remainingMilliSeconds = ((double)elapsedTime / (double)satTestedCount) * (totalToTestCount-testedClasses);
}
if (totalClasses <= 0) {
progessPercent = 0.;
} else {
progessPercent = ((double)testedClasses / (double)totalClasses) * 100.;
}
cint64 classificCount = mClassificationCount;
mClassifyProgess.setClassificationCount(classificCount);
mClassifyProgess.setProgessPercent(progessPercent);
mClassifyProgess.setRemainingMilliSeconds(remainingMilliSeconds);
mClassifyProgess.setTestedSatisfiable(testedClasses);
mClassifyProgess.setTotalSatisfiable(totalClasses);
} else {
mClassifyProgess.setProgessPercent(0.);
mClassifyProgess.setRemainingMilliSeconds(0.);
mClassifyProgess.setTestedSatisfiable(satTestedCount);
mClassifyProgess.setTotalSatisfiable(totalToTestCount);
}
return &mClassifyProgess;
}
bool COptimizedClassExtractedSaturationSubsumptionClassifierThread::createNextSubsumtionTest() {
COntologyClassificationItem *loopOntClassItem = 0;
bool workTestCreated = false;
while (!workTestCreated && !processingOntItemList.isEmpty()) {
COntologyClassificationItem *ontClassItem = processingOntItemList.first();
if (ontClassItem == loopOntClassItem) {
// don't run into infinite loop without doing something
break;
}
COptimizedClassExtractedSaturationOntologyClassificationItem *optSubClassItem = (COptimizedClassExtractedSaturationOntologyClassificationItem *)ontClassItem;
if (!workTestCreated) {
if (optSubClassItem || optSubClassItem->isTaxonomyConstructionFailed()) {
finishOntologyClassification(optSubClassItem);
processingOntItemList.removeFirst();
} else {
processingOntItemList.removeFirst();
processingOntItemList.append(ontClassItem);
loopOntClassItem = ontClassItem;
}
}
}
return workTestCreated;
}
bool COptimizedClassExtractedSaturationSubsumptionClassifierThread::interpreteTestResults(CTestCalculatedCallbackEvent *testResult) {
return false;
}
bool itemSortLessThan(const COptimizedClassExtractedSaturationSatisfiableTestingItem* item1, const COptimizedClassExtractedSaturationSatisfiableTestingItem* item2) {
return item1->getExtractionSubsumerCount() < item2->getExtractionSubsumerCount();
}
bool COptimizedClassExtractedSaturationSubsumptionClassifierThread::finishOntologyClassification(COntologyClassClassificationItem *ontClassItem) {
if (!ontClassItem->isTaxonomyConstructed() && !ontClassItem->isTaxonomyConstructionFailed()) {
CTaxonomy *taxonomy = ontClassItem->getTaxonomy();
CConcreteOntology *ontology = ontClassItem->getOntology();
LOG(INFO,getLogDomain(),logTr("Building class taxonomy for ontology '%1'.").arg(ontology->getTerminologyName()),getLogObject());
#ifdef OPTIMIZEDCLASSEXTRACTEDSATURATIONCLASSIFIERDEBUGLOGOUTPUT
LOG(INFO,getLogDomain(),QString("Building Class Taxonomy"),this);
#endif
// build taxonomy
COptimizedClassExtractedSaturationOntologyClassificationItem *optSubClassItem = (COptimizedClassExtractedSaturationOntologyClassificationItem *)ontClassItem;
QList* satItemList = optSubClassItem->getClassSatisfiableTestItemList();
COptimizedClassExtractedSaturationSatisfiableTestingItem* bottomItem = optSubClassItem->getBottomConceptSatisfiableTestItem();
CTaxonomy *tax = optSubClassItem->getTaxonomy();
QList itemList;
COptimizedClassExtractedSaturationSatisfiableTestingItem* topItem = optSubClassItem->getTopConceptSatisfiableTestItem();
CHierarchyNode* topHierNode = tax->getTopHierarchyNode();
CHierarchyNode* bottomHierNode = tax->getBottomHierarchyNode();
CPrecomputedSaturationSubsumerExtractor precSatSubsumerExtractor(ontology);
cint64 topSubsumingItemCount = topItem->getExtractionSubsumerCount();
topItem->setSatisfiableConceptHierarchyNode(topHierNode);
if (topSubsumingItemCount > 0) {
precSatSubsumerExtractor.extractSubsumers(topItem->getTestingConcept(),topItem);
QList* subsumingConceptItemList = topItem->sortSubsumingConceptItemList();
for (QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); subsumedIt != subsumedItEnd; ++subsumedIt) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem = *subsumedIt;
// mark as equivalent
subsumedConceptItem->setEquivalentItem(true);
topHierNode->addEquivalentConcept(subsumedConceptItem->getTestingConcept());
tax->updateNodeEquivalences(topHierNode);
}
}
qSort(satItemList->begin(),satItemList->end(),itemSortLessThan);
for (QList::const_iterator it = satItemList->constBegin(), itEnd = satItemList->constEnd(); it != itEnd; ++it) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* item = *it;
if (!item->isEquivalentItem() && item != bottomItem && item != topItem) {
CHierarchyNode* itemNode = tax->getHierarchyNode(item->getTestingConcept(),true);
item->setSatisfiableConceptHierarchyNode(itemNode);
cint64 itemSubsumingCount = item->getExtractionSubsumerCount();
itemList.append(item);
if (itemSubsumingCount > topSubsumingItemCount) {
CConcept* directSubsumerConcept = precSatSubsumerExtractor.getDirectSubsumerCount(item->getTestingConcept(),&isDirectSubsumer);
bool requiresDetailedSubsumerSearch = true;
if (directSubsumerConcept) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* directSubsumerItem = getItemForConcept(directSubsumerConcept);
if (!directSubsumerItem->isEquivalentItem()) {
item->setDirectSubsumer(directSubsumerItem);
requiresDetailedSubsumerSearch = false;
}
}
if (requiresDetailedSubsumerSearch) {
precSatSubsumerExtractor.extractSubsumers(item->getTestingConcept(),item);
QList* subsumingConceptItemList = item->sortSubsumingConceptItemList();
for (QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd(); subsumedIt != subsumedItEnd; ++subsumedIt) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem = *subsumedIt;
cint64 subsumedItemSubsumingCount = subsumedConceptItem->getExtractionSubsumerCount();
if (subsumedItemSubsumingCount == itemSubsumingCount) {
// mark as equivalent
subsumedConceptItem->setEquivalentItem(true);
itemNode->addEquivalentConcept(subsumedConceptItem->getTestingConcept());
tax->updateNodeEquivalences(itemNode);
} else {
break;
}
}
}
}
}
}
for (QList::const_iterator it = itemList.constBegin(), itEnd = itemList.constEnd(); it != itEnd; ++it) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* item = *it;
if (!item->isEquivalentItem() && item != topItem) {
cint64 itemSubsumingCount = item->getExtractionSubsumerCount();
CHierarchyNode* itemHierNode = item->getSatisfiableConceptHierarchyNode();
if (item->hasDirectSubsumer()) {
if (mTransitiveReductionAddAllPredecessors) {
itemHierNode->addPredecessorNode(topHierNode);
}
COptimizedClassExtractedSaturationSatisfiableTestingItem* directSubsumerItem = item->getDirectSubsumer();
directSubsumerItem->setPredecessorItem(true);
CHierarchyNode* subsumedHierNode = directSubsumerItem->getSatisfiableConceptHierarchyNode();
itemHierNode->makeParent(subsumedHierNode);
QSet* predSet = subsumedHierNode->getPredecessorNodeSet();
if (mTransitiveReductionAddAllPredecessors) {
for (QSet::const_iterator itPred = predSet->constBegin(), itPredEnd = predSet->constEnd(); itPred != itPredEnd; ++itPred) {
CHierarchyNode* predNode(*itPred);
itemHierNode->addPredecessorNode(predNode);
}
}
} else {
QList* subsumingConceptItemList = item->getSubsumingConceptItemList();
QList::const_iterator subsumedIt = subsumingConceptItemList->constBegin(), subsumedItEnd = subsumingConceptItemList->constEnd();
cint64 eqCount = 0;
cint64 remainingSubsumingCount = itemSubsumingCount;
// remove direct equivalences
while (subsumedIt != subsumedItEnd) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem = *subsumedIt;
cint64 subsumedItemSubsumingCount = subsumedConceptItem->getExtractionSubsumerCount();
if (subsumedItemSubsumingCount != itemSubsumingCount) {
break;
} else {
++eqCount;
++subsumedIt;
}
}
while (subsumedIt != subsumedItEnd && (*subsumedIt)->isEquivalentItem()) {
++subsumedIt;
}
// find first parent
if (subsumedIt == subsumedItEnd) {
// no parent, use top as parent
itemHierNode->makeParent(topHierNode);
} else {
while (subsumedIt != subsumedItEnd) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem = *subsumedIt;
if (!subsumedConceptItem->isEquivalentItem()) {
remainingSubsumingCount -= makeParentAddPredeccessors(item,subsumedConceptItem,remainingSubsumingCount,true);
++subsumedIt;
break;
} else {
++subsumedIt;
}
}
while (subsumedIt != subsumedItEnd && (remainingSubsumingCount > 0)) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem = *subsumedIt;
if (!subsumedConceptItem->isEquivalentItem()) {
remainingSubsumingCount -= makeParentAddPredeccessors(item,subsumedConceptItem,remainingSubsumingCount,false);
}
++subsumedIt;
}
//bool searchForMoreParents = remainingSubsumingCount > 0;
//while (subsumedIt != subsumedItEnd) {
// COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem = *subsumedIt;
// if (!subsumedConceptItem->isEquivalentItem()) {
// bool predOfOnePrevParent = false;
// if (searchForMoreParents) {
// for (QList::const_iterator parentIt = parentItemList.constBegin(), parentItEnd = parentItemList.constEnd(); parentIt != parentItEnd && !predOfOnePrevParent; ++parentIt) {
// COptimizedClassExtractedSaturationSatisfiableTestingItem* parentItem = *parentIt;
// if (precSatSubsumerExtractor.hasSubsumerConcept(parentItem->getTestingConcept(),subsumedConceptItem->getTestingConcept())) {
// predOfOnePrevParent = true;
// }
// }
// }
// subsumedConceptItem->setPredecessorItem(true);
// CHierarchyNode* subsumedHierNode = subsumedConceptItem->getSatisfiableConceptHierarchyNode();
// if (!predOfOnePrevParent && searchForMoreParents) {
// itemHierNode->makeParent(subsumedHierNode);
// parentItemList.append(subsumedConceptItem);
// } else {
// if (mTransitiveReductionAddAllPredecessors) {
// itemHierNode->addPredecessorNode(subsumedHierNode);
// }
// }
// }
// ++subsumedIt;
//}
}
}
}
}
for (QList::const_iterator it = itemList.constBegin(), itEnd = itemList.constEnd(); it != itEnd; ++it) {
COptimizedClassExtractedSaturationSatisfiableTestingItem* item = *it;
if (!item->isPredecessorItem() && !item->isEquivalentItem()) {
CHierarchyNode* itemHierNode = item->getSatisfiableConceptHierarchyNode();
bottomHierNode->makeParent(itemHierNode);
}
}
#ifdef OPTIMIZEDCLASSEXTRACTEDSATURATIONCLASSIFIERDEBUGSTATUSDESCRIPTION
statUpdateMutex.lock();
statusString = QString("Finished ontology classification");
statUpdateMutex.unlock();
#endif
CClassification* classification = ontology->getClassification();
if (classification) {
CClassConceptClassification* classConClassification = ontClassItem->getClassConceptClassification();
CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings();
CClassifierStatistics* classifierStats = ontClassItem->getClassifierStatistics();
classifStatCollStrings->addProcessingStatistics("class-classification-total-satisfiable-test-count",classifierStats->getTotalSatisfiableCount());
classConClassification->setClassConceptTaxonomy(taxonomy);
classConClassification->setClassificationStatistics(classifStatCollStrings);
if (ontClassItem->getIndividualDependenceTrackingCollector()) {
classConClassification->setDependentIndividualsTracking(ontClassItem->getIndividualDependenceTrackingCollector()->getExtendingIndividualDependenceTracking());
}
classification->setClassConceptClassification(classConClassification);
}
ontology->setConceptTaxonomy(taxonomy);
ontClassItem->setHasRemainingTests(false);
taxonomy->setTaxonomyComplete(true);
--mClassificationCount;
LOG(INFO,getLogDomain(),logTr("Ontology '%1' classified.").arg(ontology->getTerminologyName()),getLogObject());
}
ontClassItem->submitTaxonomyConstructed();
ontClassItem->doClassifiedCallback();
return true;
}
bool COptimizedClassExtractedSaturationSubsumptionClassifierThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CSubsumptionClassifierThread::processCustomsEvents(type,event)) {
return true;
}
return false;
}
cint64 COptimizedClassExtractedSaturationSubsumptionClassifierThread::makeParentAddPredeccessors(COptimizedClassExtractedSaturationSatisfiableTestingItem* conceptItem, COptimizedClassExtractedSaturationSatisfiableTestingItem* subsumedConceptItem, cint64 remainingSubsumingResolvingCount, bool firstResolve) {
CHierarchyNode* node = conceptItem->getSatisfiableConceptHierarchyNode();
CHierarchyNode* newParentNode = subsumedConceptItem->getSatisfiableConceptHierarchyNode();
cint64 resolvedExtSubsumerCount = 0;
if (!node->hasPredecessorNode(newParentNode)) {
if (firstResolve) {
resolvedExtSubsumerCount = subsumedConceptItem->getExtractionSubsumerCount();
} else {
resolvedExtSubsumerCount = newParentNode->getEquivalentConceptCount();
}
node->addParentNode(newParentNode);
newParentNode->addChildNode(node);
if (mTransitiveReductionAddAllPredecessors || resolvedExtSubsumerCount != remainingSubsumingResolvingCount) {
resolvedExtSubsumerCount = 0;
QList predAddList;
predAddList.append(newParentNode);
while (!predAddList.isEmpty()) {
CHierarchyNode* nextPredNode = predAddList.takeFirst();
if (!node->hasPredecessorNode(nextPredNode)) {
node->addPredecessorNode(nextPredNode);
//nextPredNode->addSuccessorNode(node);
resolvedExtSubsumerCount += nextPredNode->getEquivalentConceptCount();
QSet* nextParentPredSet = nextPredNode->getParentNodeSet();
for (QSet::const_iterator it = nextParentPredSet->constBegin(), itEnd = nextParentPredSet->constEnd(); it != itEnd; ++it) {
CHierarchyNode* nextPredPredNode(*it);
predAddList.append(nextPredPredNode);
}
}
}
} else {
node->makePredecessor(newParentNode);
}
}
return resolvedExtSubsumerCount;
}
}; // end namespace Classifier
}; // end namespace Reasoner
}; // end namespace Konclude