/*
* 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 "CSatisfiableTaskMarkerIndividualPropagationAnalyser.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CSatisfiableTaskMarkerIndividualPropagationAnalyser::CSatisfiableTaskMarkerIndividualPropagationAnalyser() {
}
bool CSatisfiableTaskMarkerIndividualPropagationAnalyser::readCalculationConfig(CCalculationConfigurationExtension *config) {
if (config) {
return true;
}
return false;
}
CIndividualProcessNode* CSatisfiableTaskMarkerIndividualPropagationAnalyser::getCorrectedIndividualNode(cint64 baseIndiID, CIndividualProcessNodeVector* indiNodeVec) {
CIndividualProcessNode* indi = indiNodeVec->getData(baseIndiID);
while (indi->hasMergedIntoIndividualNodeID()) {
indi = indiNodeVec->getData(indi->getMergedIntoIndividualNodeID());
}
return indi;
}
bool CSatisfiableTaskMarkerIndividualPropagationAnalyser::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
CSatisfiableTaskRealizationMarkedCandidatesMessageAdapter* realMessAdapter = statCalcTask->getRealizationMarkedCandidatesMessageAdapter();
if (realMessAdapter) {
CRealizationMessageObserver* realMessObserver = realMessAdapter->getRealizationMessageDataObserver();
CIndividualReference individualReference = realMessAdapter->getTestingIndividualReference();
CConcreteOntology* ontology = realMessAdapter->getTestingOntology();
CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
CTaskHandleMemoryAllocationManager* taskMemMan = calcAlgContext->getTemporaryMemoryAllocationManager();
CMemoryPoolContainer memPoolCon;
CTaskMemoryPoolAllocationManager realMessMemManCreaterMemMan(&memPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
CTaskMemoryPoolAllocationManager* tempMemAllocMan = CObjectAllocator::allocateAndConstruct(&realMessMemManCreaterMemMan);
tempMemAllocMan->initTaskMemoryPoolAllocationManager(&memPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
CContextBase* tmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(tempMemAllocMan,tempMemAllocMan);
CRealizationMessageData* realMessageData = nullptr;
CProcessingDataBox* procDataBox = calcAlgContext->getProcessingDataBox();
cint64 maxDetBranchTag = procDataBox->getMaximumDeterministicBranchTag();
CIndividualVector* indiVec = procDataBox->getOntology()->getABox()->getIndividualVector();
CMarkerIndividualNodeHash* markerIndiNodeHash = procDataBox->getMarkerIndividualNodeHash(false);
if (markerIndiNodeHash) {
for (CPROCESSHASH< CConcept*, CMarkerIndividualNodeData >::const_iterator it = markerIndiNodeHash->constBegin(), itEnd = markerIndiNodeHash->constEnd(); it != itEnd; ++it) {
CConcept* markerConcept = it.key();
CIndividualRoleCandidateTestingData testingData = realMessAdapter->getIndividualRoleCandidateTestingDataByMarkerConcept(markerConcept);
CXLinker* detIndiCandLinker = nullptr;
CXLinker* ndetIndiCandLinker = nullptr;
CMarkerIndividualNodeData data = it.value();
CXNegLinker* candIndiLinker = data.getMarkerIndividualNodeLinker();
for (CXNegLinker* candIndiLinkerIt = candIndiLinker; candIndiLinkerIt; candIndiLinkerIt = candIndiLinkerIt->getNext()) {
CIndividualProcessNode* indiNode = candIndiLinkerIt->getData();
CIndividual* candIndividual = indiNode->getNominalIndividual();
if (candIndividual) {
CXLinker* tmpLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(tempMemAllocMan);
if (candIndividual->isTemporaryIndividual()) {
tmpLinker->initLinker(CIndividualReference(candIndividual->getIndividualID()));
} else {
tmpLinker->initLinker(candIndividual);
}
bool nondeterministicallyAdded = candIndiLinkerIt->isNegated();
if (nondeterministicallyAdded) {
ndetIndiCandLinker = tmpLinker->append(ndetIndiCandLinker);
} else {
detIndiCandLinker = tmpLinker->append(detIndiCandLinker);
}
CIndividualMergingHash* indiMergingHash = indiNode->getIndividualMergingHash(false);
if (indiMergingHash) {
for (CIndividualMergingHash::const_iterator indiIt = indiMergingHash->constBegin(), indiItEnd = indiMergingHash->constEnd(); indiIt != indiItEnd; ++indiIt) {
if (indiIt.value().isMergedWithIndividual()) {
cint64 indiIDIt = indiIt.key();
CIndividual* mergedIndividual = indiVec->getData(indiIDIt);
if (mergedIndividual != candIndividual) {
CDependencyTrackPoint* mergeDepTrackPoint = indiIt.value().getDependencyTrackPoint();
bool nonDetMerged = true;
if (mergeDepTrackPoint && mergeDepTrackPoint->getBranchingTag() <= maxDetBranchTag) {
nonDetMerged = false;
}
if (nonDetMerged) {
CXLinker* nomTmpLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(tempMemAllocMan);
if (mergedIndividual->isTemporaryIndividual()) {
nomTmpLinker->initLinker(CIndividualReference(mergedIndividual->getIndividualID()));
} else {
nomTmpLinker->initLinker(mergedIndividual);
}
ndetIndiCandLinker = nomTmpLinker->append(ndetIndiCandLinker);
}
}
}
}
}
}
}
CRealizationMarkerCandidatesMessageData* realMarkCandMessageData = CObjectAllocator::allocateAndConstruct(tempMemAllocMan);
realMarkCandMessageData->initRealizationMarkerCandidatesMessageData(individualReference, testingData, markerConcept,detIndiCandLinker,ndetIndiCandLinker);
realMessageData = realMarkCandMessageData->append(realMessageData);
}
}
if (realMessageData) {
realMessObserver->tellRealizationMessage(ontology,realMessageData,memPoolCon.takeMemoryPools());
} else {
taskMemMan->releaseTemporaryMemoryPools(memPoolCon.takeMemoryPools());
}
if (individualReference.isNonEmpty()) {
return true;
}
}
return false;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude