/*
* 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 "CRealizationManager.h"
#include "CReasonerManager.h"
#include "Reasoner/Realizer/COptimizedRepresentativeKPSetOntologyRealizingThread.h"
#include "Reasoner/Realizer/CIncrementalKPSetOntologyConceptRealizingThread.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Manager {
CRealizationManager::CRealizationManager(CReasonerManager* reasonerManager) {
mReasonerManager = reasonerManager;
}
CRealizationManager::~CRealizationManager() {
}
CRealizer* CRealizationManager::getRealizer(CConcreteOntology *ontology, CConfigurationBase *config) {
CRealizer* realizer = nullptr;
mReadWriteLock.lockForRead();
realizer = mOntoRealizerHash.value(ontology);
mReadWriteLock.unlock();
if (!realizer) {
bool onlyChangedABoxAxioms = ontology->getIncrementalRevisionData()->getAxiomChangeData()->hasOnlyChangedABoxAxioms();
bool previousRealizedOntologyVersion = ontology->getIncrementalRevisionData()->getPreviousClassTypesRealizedOntology() != nullptr;
mReadWriteLock.lockForWrite();
realizer = mOntoRealizerHash.value(ontology);
if (!realizer) {
if (previousRealizedOntologyVersion && onlyChangedABoxAxioms) {
realizer = new CIncrementalKPSetOntologyConceptRealizingThread(mReasonerManager);
} else {
realizer = new COptimizedRepresentativeKPSetOntologyRealizingThread(mReasonerManager);
}
mOntoRealizerHash.insert(ontology,realizer);
mRealizerSet.insert(realizer);
}
mReadWriteLock.unlock();
}
return realizer;
}
CRealizationProgress* CRealizationManager::getRealizationProgress() {
CRealizationProgress newRealProg;
mReadWriteLock.lockForRead();
double percentAvg = 0;
cint64 percentCount = 0;
foreach (CRealizer* realizer, mRealizerSet) {
CRealizationProgress* realizationProgress = realizer->getRealizationProgress();
if (realizationProgress) {
newRealProg.setTotalClasses(newRealProg.getTotalClasses()+realizationProgress->getTotalClasses());
newRealProg.setRealizationCount(newRealProg.getRealizationCount()+realizationProgress->getRealizationCount());
newRealProg.setTestedClasses(newRealProg.getTestedClasses()+realizationProgress->getTestedClasses());
newRealProg.setRemainingMilliSeconds(qMax(newRealProg.getRemainingMilliSeconds(),realizationProgress->getRemainingMilliSeconds()));
percentAvg += realizationProgress->getProgessPercent();
++percentCount;
}
}
mReadWriteLock.unlock();
if (percentCount != 0) {
percentAvg /= (double)percentCount;
}
newRealProg.setProgessPercent(percentAvg);
mRealizationProgress = newRealProg;
return &mRealizationProgress;
}
}; // end namespace Manager
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude