/* * 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 "CSaturationNodeExpansionCacheHandler.h" namespace Konclude { namespace Reasoner { namespace Kernel { namespace Algorithm { CSaturationNodeExpansionCacheHandler::CSaturationNodeExpansionCacheHandler(CSaturationNodeAssociatedExpansionCacheReader* satCacheReader, CSaturationNodeAssociatedExpansionCacheWriter* satCacheWriter) { mSatCacheReader = satCacheReader; mSatCacheWriter = satCacheWriter; mTmpContext = nullptr; mMemAllocMan = nullptr; mWriteData = nullptr; } CIndividualSaturationProcessNode* CSaturationNodeExpansionCacheHandler::getSaturationIndividualNodeForConcept(CConcept* concept, bool negation, CCalculationAlgorithmContext* calcAlgContext) { CConceptData* conceptData = concept->getConceptData(); CIndividualSaturationProcessNode* saturationIndiNode = nullptr; if (conceptData) { CConceptProcessData* conProcData = (CConceptProcessData*)conceptData; CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking(); if (conRefLinking) { CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking; CSaturationConceptReferenceLinking* satCalcRefLinkData = confSatRefLinkingData->getConceptSaturationReferenceLinkingData(false); if (satCalcRefLinkData) { saturationIndiNode = (CIndividualSaturationProcessNode*)satCalcRefLinkData->getIndividualProcessNodeForConcept(); } } } return saturationIndiNode; } bool CSaturationNodeExpansionCacheHandler::cacheUnsatisfiableConcept(CConcept* concept, CCalculationAlgorithmContext* calcAlgContext) { CIndividualSaturationProcessNode* saturationIndiNode = getSaturationIndividualNodeForConcept(concept,false,calcAlgContext); if (saturationIndiNode && !saturationIndiNode->getIndirectStatusFlags()->hasClashedFlag()) { // try caching prepareCacheMessages(calcAlgContext); CTaskMemoryPoolAllocationManager* satCacheMemMan = mMemAllocMan; CContextBase* tmpContext = mTmpContext; CSaturationNodeAssociatedExpansionCacheUnsatisfiabilityWriteData* unsatWriteData = CObjectAllocator< CSaturationNodeAssociatedExpansionCacheUnsatisfiabilityWriteData >::allocateAndConstruct(satCacheMemMan); unsatWriteData->initUnsatisfiabilityWriteData(saturationIndiNode); addCacheMessages(unsatWriteData,calcAlgContext); return true; } return false; } bool CSaturationNodeExpansionCacheHandler::isConceptUnsatisfiableCached(CConcept* concept, bool negation, CCalculationAlgorithmContext* calcAlgContext) { CIndividualSaturationProcessNode* saturationIndiNode = getSaturationIndividualNodeForConcept(concept,negation,calcAlgContext); if (saturationIndiNode) { return saturationIndiNode->getIndirectStatusFlags()->hasClashedFlag(); } return false; } bool CSaturationNodeExpansionCacheHandler::isNodeSatisfiableCached(CIndividualProcessNode* individualProcessNode, CSaturationNodeAssociatedConceptExpansion*& expansion, CCalculationAlgorithmContext* calcAlgContext) { CIndividualNodeSaturationBlockingData* satBlockData = individualProcessNode->getIndividualSaturationBlockingData(false); CReapplyConceptLabelSet* conSet = individualProcessNode->getReapplyConceptLabelSet(false); if (conSet && satBlockData) { cint64 totalConceptCount = conSet->getConceptCount(); CConceptDescriptor* lastAddedConDes = conSet->getAddingSortedConceptDescriptionLinker(); CIndividualSaturationProcessNode* saturationNode = satBlockData->getSaturationIndividualNode(); if (satBlockData->getLastConfirmedConceptDescriptior() == lastAddedConDes) { CIndividualSaturationProcessNodeStatusFlags* flags = saturationNode->getIndirectStatusFlags(); if (!flags->hasFlags(CIndividualSaturationProcessNodeStatusFlags::INDSATFLAGINSUFFICIENT | CIndividualSaturationProcessNodeStatusFlags::INDSATFLAGCLASHED,false)) { return true; } } CReapplyConceptSaturationLabelSet* satConSet = saturationNode->getReapplyConceptSaturationLabelSet(false); CSaturationNodeAssociatedExpansionCacheEntry* cacheEntry = mSatCacheReader->getCacheEntry(saturationNode); if (cacheEntry) { CConceptDescriptor* lastConDes = satBlockData->getLastConfirmedConceptDescriptior(); CConceptDescriptor* conDes = conSet->getAddingSortedConceptDescriptionLinker(); cint64 conSetSignature = conSet->getConceptSignature()->getSignatureValue(); CSaturationNodeAssociatedDeterministicConceptExpansion* detExpansion = cacheEntry->getDeterministicConceptExpansion(); if (detExpansion && !detExpansion->requiresNonDeterministicExpansion()) { if (testNodeMatchingExpansion(detExpansion,nullptr,conSet,satBlockData,calcAlgContext)) { expansion = detExpansion; return true; } } CSaturationNodeAssociatedNondeterministicConceptExpansion* nondetExpansionLinker = cacheEntry->getNondeterministicConceptExpansionLinker(); for (CSaturationNodeAssociatedNondeterministicConceptExpansion* nondetExpansionLinkerIt = nondetExpansionLinker; nondetExpansionLinkerIt; nondetExpansionLinkerIt = nondetExpansionLinkerIt->getNext()) { CSaturationNodeAssociatedNondeterministicConceptExpansion* nondetExpansion = nondetExpansionLinkerIt; if (testNodeMatchingExpansion(nondetExpansion,detExpansion,conSet,satBlockData,calcAlgContext)) { expansion = nondetExpansion; return true; } } } } return false; } bool CSaturationNodeExpansionCacheHandler::getCachedDeterministicExpansion(CIndividualSaturationProcessNode* saturationNode, CSaturationNodeAssociatedDeterministicConceptExpansion*& expansion, CCalculationAlgorithmContext* calcAlgContext) { CSaturationNodeAssociatedExpansionCacheEntry* cacheEntry = mSatCacheReader->getCacheEntry(saturationNode); if (cacheEntry) { CSaturationNodeAssociatedDeterministicConceptExpansion* detExpansion = cacheEntry->getDeterministicConceptExpansion(); if (detExpansion) { expansion = detExpansion; return true; } } return false; } bool CSaturationNodeExpansionCacheHandler::testNodeMatchingExpansion(CSaturationNodeAssociatedConceptExpansion* expansion, CSaturationNodeAssociatedConceptExpansion* alternativeExpansion, CReapplyConceptLabelSet* conSet, CIndividualNodeSaturationBlockingData* satBlockData, CCalculationAlgorithmContext* calcAlgContext) { cint64 conSetSignature = conSet->getConceptSignature()->getSignatureValue(); if (expansion->getConceptSetSignature() != conSetSignature) { return false; } cint64 totalConceptCount = conSet->getConceptCount(); if (expansion->getTotalConceptCount() != totalConceptCount) { return false; } CConceptDescriptor* lastConDes = satBlockData->getLastConfirmedConceptDescriptior(); CConceptDescriptor* conDes = conSet->getAddingSortedConceptDescriptionLinker(); for (CConceptDescriptor* conDesIt = conDes; conDesIt != lastConDes; conDesIt = conDesIt->getNext()) { CCacheValue cacheValue(getCacheValueForConcept(conDesIt,calcAlgContext)); if (!expansion->hasConceptExpansionLinker(&cacheValue)) { if (!alternativeExpansion || !alternativeExpansion->hasConceptExpansionLinker(&cacheValue)) { return false; } } } CSaturationNodeAssociatedDependentNominalSet* dependentNominalSet = expansion->getDependentNominalSet(false); if (dependentNominalSet) { CIndividualProcessNodeVector* indiVec = calcAlgContext->getProcessingDataBox()->getIndividualProcessNodeVector(); for (CSaturationNodeAssociatedDependentNominalSet::const_iterator it = dependentNominalSet->constBegin(), itEnd = dependentNominalSet->constEnd(); it != itEnd; ++it) { cint64 dependentNominalID = -(*it); bool nominalStillCached = false; CIndividualProcessNode* indiNode = indiVec->getData(dependentNominalID); if (indiNode) { if (dependentNominalID <= calcAlgContext->getMaxCompletionGraphCachedIndividualNodeID() && indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHED)) { if (!indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID) && !indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED)) { nominalStillCached = true; } } else if (indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKEND)) { nominalStillCached = true; } } else { nominalStillCached = true; } if (!nominalStillCached) { return false; } } } return true; } CCacheValue CSaturationNodeExpansionCacheHandler::getCacheValueForConcept(CConceptDescriptor* conDes, CCalculationAlgorithmContext* calcAlgContext) { return getCacheValueForConcept(conDes->getConcept(),conDes->isNegated(),calcAlgContext); } CCacheValue CSaturationNodeExpansionCacheHandler::getCacheValueForConcept(CConcept* concept, bool negation, CCalculationAlgorithmContext* calcAlgContext) { cint64 conTag = concept->getConceptTag(); CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT; if (negation) { cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT; } CCacheValue cacheValue; cacheValue.initCacheValue(conTag,(cint64)concept,cacheValueIdentifier); return cacheValue; } bool CSaturationNodeExpansionCacheHandler::prepareCacheMessages(CCalculationAlgorithmContext* calcAlgContext) { if (!mMemAllocMan) { CTaskMemoryPoolAllocationManager satCacheMemManCreaterMemMan(&mMemPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager()); mMemAllocMan = CObjectAllocator::allocateAndConstruct(&satCacheMemManCreaterMemMan); mMemAllocMan->initTaskMemoryPoolAllocationManager(&mMemPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager()); mTmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(mMemAllocMan,mMemAllocMan); return true; } return false; } bool CSaturationNodeExpansionCacheHandler::commitCacheMessages(CCalculationAlgorithmContext* calcAlgContext) { if (mWriteData) { CSaturationNodeAssociatedExpansionCacheWriteData* commitWriteData = nullptr; CSaturationNodeAssociatedExpansionCacheWriteData* writeDataIt = mWriteData; while (writeDataIt) { CSaturationNodeAssociatedExpansionCacheWriteData* tmpWriteData = writeDataIt; writeDataIt = (CSaturationNodeAssociatedExpansionCacheWriteData*)writeDataIt->getNext(); tmpWriteData->clearNext(); if (commitWriteData) { commitWriteData = (CSaturationNodeAssociatedExpansionCacheWriteData*)tmpWriteData->append(commitWriteData); } else { commitWriteData = tmpWriteData; } } mSatCacheWriter->writeCacheData(commitWriteData,mMemPoolCon.takeMemoryPools()); mWriteData = nullptr; mMemAllocMan = nullptr; mTmpContext = nullptr; return true; } return false; } bool CSaturationNodeExpansionCacheHandler::addCacheMessages(CSaturationNodeAssociatedExpansionCacheWriteData* expandWriteData, CCalculationAlgorithmContext* calcAlgContext) { if (mWriteData) { mWriteData = (CSaturationNodeAssociatedExpansionCacheWriteData*)expandWriteData->append(mWriteData); } else { mWriteData = expandWriteData; } //commitCacheMessages(calcAlgContext); return true; } bool CSaturationNodeExpansionCacheHandler::testNodeCachingPossible(CIndividualProcessNode* individualProcessNode, bool& onlyIfCompletelyDeterministic, bool& onlyAllNondeterministic, CSaturationNodeAssociatedExpansionCacheEntry*& cacheEntry, CCalculationAlgorithmContext* calcAlgContext) { onlyIfCompletelyDeterministic = false; cacheEntry = nullptr; CIndividualNodeSaturationBlockingData* satBlockData = individualProcessNode->getIndividualSaturationBlockingData(false); CReapplyConceptLabelSet* conSet = individualProcessNode->getReapplyConceptLabelSet(false); if (conSet && satBlockData) { cint64 totalConceptCount = conSet->getConceptCount(); CConceptDescriptor* lastAddedConDes = conSet->getAddingSortedConceptDescriptionLinker(); CIndividualSaturationProcessNode* saturationNode = satBlockData->getSaturationIndividualNode(); CReapplyConceptSaturationLabelSet* satConSet = saturationNode->getReapplyConceptSaturationLabelSet(false); if (!saturationNode->isCompleted()) { return false; } cacheEntry = mSatCacheReader->getCacheEntry(saturationNode); if (cacheEntry) { cint64 conSetSignature = conSet->getConceptSignature()->getSignatureValue(); CSaturationNodeAssociatedDeterministicConceptExpansion* conExp = cacheEntry->getDeterministicConceptExpansion(); if (conExp && !conExp->requiresNonDeterministicExpansion()) { return false; } if (!cacheEntry->areMoreNondeterministicExpansionAllowed() || conExp && conExp->getConceptSetSignature() == conSetSignature) { onlyIfCompletelyDeterministic = true; } else { for (CSaturationNodeAssociatedNondeterministicConceptExpansion* conExpIt = cacheEntry->getNondeterministicConceptExpansionLinker(); conExpIt; conExpIt = conExpIt->getNext()) { if (conExpIt->getConceptSetSignature() == conSetSignature) { onlyIfCompletelyDeterministic = true; break; } } } } // test compatible nominal nodes CSuccessorConnectedNominalSet* depNominalSet = individualProcessNode->getSuccessorNominalConnectionSet(false); if (depNominalSet) { CIndividualProcessNodeVector* indiVec = calcAlgContext->getProcessingDataBox()->getIndividualProcessNodeVector(); for (CSuccessorConnectedNominalSet::const_iterator it = depNominalSet->constBegin(), itEnd = depNominalSet->constEnd(); it != itEnd; ++it) { cint64 nominalNodeID = *it; bool nominalStillCached = false; CIndividualProcessNode* indiNode = indiVec->getData(nominalNodeID); if (indiNode) { if (nominalNodeID <= calcAlgContext->getMaxCompletionGraphCachedIndividualNodeID() && indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHED)) { if (!indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALID) && !indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHINGINVALIDATED)) { nominalStillCached = true; if (indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFCOMPLETIONGRAPHCACHEDNODEEXTENDED)) { onlyAllNondeterministic = true; } } } else if (indiNode->hasProcessingRestrictionFlags(CIndividualProcessNode::PRFSYNCHRONIZEDBACKEND)) { nominalStillCached = true; } } if (!nominalStillCached) { return false; } } } return true; } return false; } bool CSaturationNodeExpansionCacheHandler::tryNodeSatisfiableCaching(CIndividualProcessNode* individualProcessNode, CCalculationAlgorithmContext* calcAlgContext) { // test whether node can be cached bool cachingOnlyIfDeterministic = false; bool onlyAllNondeterministic = false; CSaturationNodeAssociatedExpansionCacheEntry* cacheEntry = nullptr; if (testNodeCachingPossible(individualProcessNode,cachingOnlyIfDeterministic,onlyAllNondeterministic,cacheEntry,calcAlgContext)) { CIndividualNodeSaturationBlockingData* satBlockData = individualProcessNode->getIndividualSaturationBlockingData(false); CConceptDescriptor* lastConDes = satBlockData->getLastConfirmedConceptDescriptior(); CIndividualSaturationProcessNode* satIndiNode = satBlockData->getSaturationIndividualNode(); CSaturationConceptDataItem* conceptSatItem = (CSaturationConceptDataItem*)satIndiNode->getSaturationConceptReferenceLinking();; if (conceptSatItem) { CConcept* saturationConcept = conceptSatItem->getSaturationConcept(); //if (CIRIName::getRecentIRIName(saturationConcept->getClassNameLinker()) == "http://www.owllink.org/testsuite/galen#Transport") { // bool debug = true; //} CReapplyConceptLabelSet* conSet = individualProcessNode->getReapplyConceptLabelSet(false); cint64 totalConceptCount = conSet->getConceptCount(); cint64 conSetSignature = conSet->getConceptSignature()->getSignatureValue(); CConceptDescriptor* conDes = conSet->getAddingSortedConceptDescriptionLinker(); CConceptDescriptor* lastPossiblyNonDeterministicConDes = nullptr; CConceptDescriptor* satConDes = nullptr; CDependencyTrackPoint* satConDepTrackPoint = nullptr; if (conSet->getConceptDescriptor(saturationConcept,satConDes,satConDepTrackPoint)) { for (CConceptDescriptor* conDesIt = conDes; conDesIt != lastConDes; conDesIt = conDesIt->getNext()) { CDependencyTrackPoint* depTrackPoint = conDesIt->getDependencyTrackPoint(); if (onlyAllNondeterministic) { lastPossiblyNonDeterministicConDes = conDesIt; } else if (!isDeterministicallyDependingOnSaturationConcept(individualProcessNode,depTrackPoint,satConDes,calcAlgContext)) { lastPossiblyNonDeterministicConDes = conDesIt; } } if (!cachingOnlyIfDeterministic || lastPossiblyNonDeterministicConDes == nullptr) { prepareCacheMessages(calcAlgContext); CTaskMemoryPoolAllocationManager* satCacheMemMan = mMemAllocMan; CContextBase* tmpContext = mTmpContext; CSaturationNodeAssociatedExpansionCacheExpansionWriteData* detExpWriteData = nullptr; CSaturationNodeAssociatedExpansionCacheExpansionWriteData* nondetExpWriteData = nullptr; bool hasTightAtMostRestriction = false; for (CConceptDescriptor* conDesIt = conDes; conDesIt && !hasTightAtMostRestriction; conDesIt = conDesIt->getNext()) { CConcept* concept = conDesIt->getConcept(); bool negation = conDesIt->isNegated(); cint64 conCode = concept->getConceptOperator()->getOperatorCode(); if (negation && conCode == CCATLEAST || !negation && conCode == CCATMOST) { CRole* role = concept->getRole(); cint64 parameter = concept->getParameter(); cint64 cardinality = parameter+1*negation; if (individualProcessNode->getRoleSuccessorCount(role) >= cardinality) { hasTightAtMostRestriction = true; } } } CSaturationNodeAssociatedDependentNominalSet* nomDepSet = nullptr; CSuccessorConnectedNominalSet* successorNominalConnSet = individualProcessNode->getSuccessorNominalConnectionSet(false); if (successorNominalConnSet) { nomDepSet = CObjectParameterizingAllocator< CSaturationNodeAssociatedDependentNominalSet,CContext* >::allocateAndConstructAndParameterize(satCacheMemMan,tmpContext); for (CSuccessorConnectedNominalSet::const_iterator it = successorNominalConnSet->constBegin(), itEnd = successorNominalConnSet->constEnd(); it != itEnd; ++it) { cint64 nominalID = -(*it); nomDepSet->insert(nominalID); } } if (lastPossiblyNonDeterministicConDes) { // create non-deterministic expansion data nondetExpWriteData = CObjectAllocator< CSaturationNodeAssociatedExpansionCacheExpansionWriteData >::allocateAndConstruct(satCacheMemMan); CSaturationNodeAssociatedConceptLinker* nonDetConceptLinker = nullptr; CConceptDescriptor* conDesStop = lastPossiblyNonDeterministicConDes->getNext(); for (CConceptDescriptor* conDesIt = conDes; conDesIt != conDesStop; conDesIt = conDesIt->getNext()) { const CCacheValue& cacheValue(getCacheValueForConcept(conDesIt->getConcept(),conDesIt->isNegated(),calcAlgContext)); CSaturationNodeAssociatedConceptLinker* assConceptLinker = CObjectAllocator< CSaturationNodeAssociatedConceptLinker >::allocateAndConstruct(satCacheMemMan); assConceptLinker->initConceptLinker(cacheValue); nonDetConceptLinker = assConceptLinker->append(nonDetConceptLinker); } nondetExpWriteData->initExpansionWriteData(satIndiNode,nonDetConceptLinker); nondetExpWriteData->setDeterministicExpansion(false); nondetExpWriteData->setTightAtMostRestriction(hasTightAtMostRestriction); nondetExpWriteData->setConceptSetSignature(conSetSignature); nondetExpWriteData->setTotalConceptCount(totalConceptCount); nondetExpWriteData->setDependentNominalSet(nomDepSet); } if (!lastPossiblyNonDeterministicConDes || lastPossiblyNonDeterministicConDes->getNext() != lastConDes) { CSaturationNodeAssociatedDeterministicConceptExpansion* detConExp = nullptr; if (cacheEntry) { detConExp = cacheEntry->getDeterministicConceptExpansion(); } CSaturationNodeAssociatedConceptLinker* detConceptLinker = nullptr; CConceptDescriptor* conDesStart = nullptr; if (lastPossiblyNonDeterministicConDes) { conDesStart = lastPossiblyNonDeterministicConDes->getNext(); } if (!conDesStart) { conDesStart = conDes; } for (CConceptDescriptor* conDesIt = conDesStart; conDesIt != lastConDes; conDesIt = conDesIt->getNext()) { CCacheValue cacheValue(getCacheValueForConcept(conDesIt->getConcept(),conDesIt->isNegated(),calcAlgContext)); if (!detConExp || !detConExp->hasConceptExpansionLinker(&cacheValue)) { CSaturationNodeAssociatedConceptLinker* assConceptLinker = CObjectAllocator< CSaturationNodeAssociatedConceptLinker >::allocateAndConstruct(satCacheMemMan); assConceptLinker->initConceptLinker(cacheValue); detConceptLinker = assConceptLinker->append(detConceptLinker); } } if (detConceptLinker || !detConExp || detConExp->requiresNonDeterministicExpansion() && !detConceptLinker) { detExpWriteData = CObjectAllocator< CSaturationNodeAssociatedExpansionCacheExpansionWriteData >::allocateAndConstruct(satCacheMemMan); detExpWriteData->initExpansionWriteData(satIndiNode,detConceptLinker); detExpWriteData->setDeterministicExpansion(true); if (!lastPossiblyNonDeterministicConDes) { detExpWriteData->setRequiresNondeterministicExpansion(false); detExpWriteData->setTightAtMostRestriction(hasTightAtMostRestriction); detExpWriteData->setConceptSetSignature(conSetSignature); detExpWriteData->setTotalConceptCount(totalConceptCount); detExpWriteData->setDependentNominalSet(nomDepSet); } } } bool wroteCacheData = false; if (nondetExpWriteData) { wroteCacheData = true; addCacheMessages(nondetExpWriteData,calcAlgContext); } if (detExpWriteData) { wroteCacheData = true; addCacheMessages(detExpWriteData,calcAlgContext); } return wroteCacheData; } } } } return false; } bool CSaturationNodeExpansionCacheHandler::isDeterministicallyDependingOnSaturationConcept(CIndividualProcessNode* individualNode, CDependencyTrackPoint* depTrackPoint, CConceptDescriptor* saturationConceptDescriptor, CCalculationAlgorithmContext* calcAlgContext) { CDependencyTrackPoint* satConDepTrackPoint = saturationConceptDescriptor->getDependencyTrackPoint(); if (!satConDepTrackPoint || !depTrackPoint) { return false; } else { if (satConDepTrackPoint->getBranchingTag() != depTrackPoint->getBranchingTag()) { return false; } } cint64 ancDepth = individualNode->getIndividualAncestorDepth(); if (ancDepth <= 0) { if (depTrackPoint->isPointingToIndependentDependencyNode()) { return false; } } else { CDependencyNode* depNode = depTrackPoint->getDependencyNode(); if (depNode->hasAppropriateIndividualNode()) { CIndividualProcessNode* appIndiNode = depNode->getAppropriateIndividualNode(); cint64 appIndiAncDepth = appIndiNode->getIndividualAncestorDepth(); if (appIndiAncDepth < ancDepth) { return false; } //if (!appIndiNode->isNominalIndividual()) { //} } else { CDependencyNode::DEPENDENCNODEYTYPE depType = depNode->getDependencyType(); if (depType == CDependencyNode::DNTMERGEDCONCEPT) { return false; } } } return true; } }; // end namespace Algorithm }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude