/*
* 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 "CClassificationManager.h"
namespace Konclude {
namespace Reasoner {
namespace Classifier {
CClassificationManager::CClassificationManager() {
}
CClassificationManager::~CClassificationManager() {
if (mClassifierFac) {
delete mClassifierFac;
}
}
cint64 CClassificationManager::getActiveClassifierCount() {
readWriteLock.lockForRead();
cint64 activeCount = 0;
foreach (CSubsumptionClassifier* classifier, mOntoClassifierSet) {
CSubsumptionClassifierThread* threadClassifier = dynamic_cast(classifier);
if (threadClassifier && threadClassifier->isClassifierActive()) {
++activeCount;
}
}
readWriteLock.unlock();
return activeCount;
}
CClassificationManager *CClassificationManager::initializeManager(CSubsumptionClassifierFactory *takeClassifierFactory, CConfigurationProvider *configurationProvider) {
mClassifierFac = takeClassifierFactory;
return this;
}
CSubsumptionClassifier *CClassificationManager::getClassClassifier(CConcreteOntology *ontology, CConfigurationBase *config, bool create, bool backgroundClassification) {
readWriteLock.lockForRead();
CSubsumptionClassifier *classifier = mOntoClassifierHash.value(ontology);
readWriteLock.unlock();
if (!classifier) {
readWriteLock.lockForWrite();
classifier = mOntoClassifierHash.value(ontology);
if (!classifier) {
classifier = mClassifierFac->createClassifier(ontology,config);
mOntoClassifierSet.insert(classifier);
mOntoClassifierHash.insert(ontology,classifier);
}
readWriteLock.unlock();
}
return classifier;
}
CClassifierStatistics *CClassificationManager::collectClassificationStatistics(CClassifierStatistics *statistics) {
statistics->resetValues();
readWriteLock.lockForRead();
foreach (CSubsumptionClassifier *classifier, mOntoClassifierSet) {
CClassifierStatistics *classifierStatistics = classifier->getClassificationStatistics();
statistics->appendStatistics(classifierStatistics);
}
readWriteLock.unlock();
return statistics;
}
QList CClassificationManager::getClassifierList() {
readWriteLock.lockForRead();
QList list(mOntoClassifierSet.values());
readWriteLock.unlock();
return list;
}
CClassificationProgress* CClassificationManager::getClassificationProgress() {
CClassificationProgress newClassProg;
readWriteLock.lockForRead();
double percentAvg = 0;
cint64 percentCount = 0;
foreach (CSubsumptionClassifier *classifier, mOntoClassifierSet) {
CClassificationProgress* classificationProgress = classifier->getClassificationProgress();
if (classificationProgress) {
newClassProg.setTotalSatisfiable(newClassProg.getTotalSatisfiable()+classificationProgress->getTotalSatisfiable());
newClassProg.setClassificationCount(newClassProg.getClassificationCount()+classificationProgress->getClassificationCount());
newClassProg.setTestedSatisfiable(newClassProg.getTestedSatisfiable()+classificationProgress->getTestedSatisfiable());
newClassProg.setTestedSubsumptions(newClassProg.getTestedSubsumptions()+classificationProgress->getTestedSubsumptions());
newClassProg.setTotalSubsumptions(newClassProg.getTotalSubsumptions()+classificationProgress->getTotalSubsumptions());
newClassProg.setRemainingMilliSeconds(qMax(newClassProg.getRemainingMilliSeconds(),classificationProgress->getRemainingMilliSeconds()));
percentAvg += classificationProgress->getProgessPercent();
++percentCount;
}
}
readWriteLock.unlock();
if (percentCount != 0) {
percentAvg /= (double)percentCount;
}
newClassProg.setProgessPercent(percentAvg);
mClassificationProgress = newClassProg;
return &mClassificationProgress;
}
CSubsumptionClassifier* CClassificationManager::getDataPropertyClassifier(CConcreteOntology *ontology, CConfigurationBase *config) {
readWriteLock.lockForRead();
CSubsumptionClassifier *classifier = mOntoDataPropertyClassifierHash.value(ontology);
readWriteLock.unlock();
if (!classifier) {
readWriteLock.lockForWrite();
classifier = mOntoDataPropertyClassifierHash.value(ontology);
if (!classifier) {
classifier = mClassifierFac->getDataPropertyClassifier(ontology,config);
mOntoClassifierSet.insert(classifier);
mOntoDataPropertyClassifierHash.insert(ontology,classifier);
}
readWriteLock.unlock();
}
return classifier;
}
CSubsumptionClassifier* CClassificationManager::getObjectPropertyClassifier(CConcreteOntology *ontology, CConfigurationBase *config) {
readWriteLock.lockForRead();
CSubsumptionClassifier *classifier = mOntoObjectPropertyClassifierHash.value(ontology);
readWriteLock.unlock();
if (!classifier) {
readWriteLock.lockForWrite();
classifier = mOntoObjectPropertyClassifierHash.value(ontology);
if (!classifier) {
classifier = mClassifierFac->getObjectPropertyClassifier(ontology,config);
mOntoClassifierSet.insert(classifier);
mOntoObjectPropertyClassifierHash.insert(ontology,classifier);
}
readWriteLock.unlock();
}
return classifier;
}
}; // end namespace Classifier
}; // end namespace Reasoner
}; // end namespace Konclude