/* * 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 "CSatisfiableCalculationTaskFromCalculationJobGenerator.h" namespace Konclude { namespace Reasoner { namespace Generator { CSatisfiableCalculationTaskFromCalculationJobGenerator::CSatisfiableCalculationTaskFromCalculationJobGenerator(CGeneratorTaskHandleContextBase* genTaskHandleContext) { mGenTaskHandleContext = genTaskHandleContext; } CSatisfiableCalculationTask* CSatisfiableCalculationTaskFromCalculationJobGenerator::createSatisfiableCalculationTask(CCalculationJob* calculationJob, CCallbackData* additionalCalculatedCallback) { return createSatisfiableCalculationTask(calculationJob->getOntology(),calculationJob,additionalCalculatedCallback); } CSatisfiableCalculationTask* CSatisfiableCalculationTaskFromCalculationJobGenerator::createApproximatedSaturationCalculationTask(CConcreteOntology *ontology, CApproximatedSaturationCalculationJob* approxSaturCalcJob, CCallbackData* additionalCalculatedCallback) { CSatisfiableCalculationTask* baseTask = nullptr; CSaturationData* saturData = approxSaturCalcJob->getContinueSaturationData(); if (saturData) { CSaturationTaskData* taskSaturData = dynamic_cast(saturData); if (taskSaturData) { baseTask = taskSaturData->getSaturationTask(); } } CSatisfiableCalculationTask* satCalcTask = CObjectMemoryPoolAllocator::allocateAndConstructWithMemroyPool(mGenTaskHandleContext->getTaskHandleMemoryAllocationManager()); if (baseTask) { satCalcTask->initUndependedSatisfiableCalculationTask(baseTask,approxSaturCalcJob->getCalculationConfiguration(),approxSaturCalcJob->getCalclulationStatisticsCollector(),mGenTaskHandleContext); } else { satCalcTask->initSatisfiableCalculationTask(ontology,approxSaturCalcJob->getCalculationConfiguration(),approxSaturCalcJob->getCalclulationStatisticsCollector(),mGenTaskHandleContext); } CProcessContext* procContext = satCalcTask->getProcessContext(mGenTaskHandleContext); CProcessingDataBox* dataBox = satCalcTask->getProcessingDataBox(); if (approxSaturCalcJob->getOccurrenceStatisticsCollectingAdapter()) { dataBox->setNominalDelayedIndividualSaturationProcessNodeLinker(nullptr); } CIndividualSaturationProcessNodeVector* indiNodeVec = dataBox->getIndividualSaturationProcessNodeVector(); CMemoryAllocationManager* memMan = procContext->getUsedMemoryAllocationManager(); cint64 nextIndiID = qMax((cint64)1,indiNodeVec->getItemCount()); nextIndiID = qMax(nextIndiID, dataBox->getOntology()->getABox()->getNextIndividualId(false) + 1); bool separateSaturation = approxSaturCalcJob->isSeparateSaturation(); CIndividualVector* indiVector = dataBox->getIndividualVector(true); CApproximatedSaturationCalculationConstructionConstruct* satCalcConsConstruct = approxSaturCalcJob->getSatisfiableCalculationConstructionConstructs(); while (satCalcConsConstruct) { CSaturationConceptReferenceLinking* satConRefLink = satCalcConsConstruct->getSaturationConceptReferenceLinking(); CSaturationIndividualReferenceLinking* satIndiRefLink = satCalcConsConstruct->getSaturationIndividualReferenceLinking(); CIndividual* nominalIndi = satCalcConsConstruct->getIndividual(); cint64 individualID = 1; bool nominalIndiTriplesAssertions = false; if (!nominalIndi && satCalcConsConstruct->getIndividualID() >= 0) { individualID = satCalcConsConstruct->getIndividualID(); nominalIndi = CObjectAllocator::allocateAndConstruct(memMan); nominalIndi->initIndividual(individualID); nominalIndi->setTemporaryIndividual(true); indiVector->setLocalData(individualID, nominalIndi); if (satIndiRefLink) { CIndividualProcessData* nominalIndiProData = CObjectAllocator::allocateAndConstruct(memMan); nominalIndiProData->initIndividualProcessExtensionData(); nominalIndiProData->setSaturationReferenceLinkingData(satIndiRefLink); nominalIndi->setIndividualData(nominalIndiProData); } nominalIndiTriplesAssertions = true; } else if (nominalIndi) { individualID = (nominalIndi->getIndividualID()); nominalIndiTriplesAssertions = nominalIndi->hasIndividualName(); nominalIndiTriplesAssertions = true; } else { individualID = nextIndiID++; } CIndividualSaturationProcessNode* indiNode = CObjectParameterizingAllocator< CIndividualSaturationProcessNode,CProcessContext* >::allocateAndConstructAndParameterize(memMan,procContext); indiNode->initIndividualSaturationProcessNode(individualID,satConRefLink,satIndiRefLink); if (nominalIndi) { indiNode->setNominalIndividual(nominalIndi); } indiNode->setSeparated(separateSaturation); indiNode->setNominalIndividualTriplesAssertions(nominalIndiTriplesAssertions); if (satConRefLink) { satConRefLink->setIndividualProcessNodeForConcept(indiNode); } if (satIndiRefLink) { satIndiRefLink->setIndividualProcessNodeForIndividual(indiNode); } indiNodeVec->setLocalData(individualID,indiNode); bool processing = satCalcConsConstruct->getQueueProcessing(); CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = CObjectAllocator< CIndividualSaturationProcessNodeLinker >::allocateAndConstruct(memMan); indiProcNodeLinker->initProcessNodeLinker(indiNode,processing); indiNode->setIndividualSaturationProcessNodeLinker(indiProcNodeLinker); if (processing) { dataBox->addIndividualSaturationProcessNodeLinker(indiProcNodeLinker); } satCalcConsConstruct = satCalcConsConstruct->getNextConstruct(); } CApproximatedSaturationCalculationProcessingConstruct* satCalcProcConstruct = approxSaturCalcJob->getSatisfiableCalculationProcessingConstructs(); while (satCalcProcConstruct) { CSaturationConceptReferenceLinking* satConRefLink = satCalcProcConstruct->getSaturationConceptReferenceLinking(); if (satConRefLink) { CIndividualSaturationProcessNode* indiNode = (CIndividualSaturationProcessNode*)satConRefLink->getIndividualProcessNodeForConcept(); if (!indiNode->isInitialized()) { CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = indiNode->getIndividualSaturationProcessNodeLinker(); indiProcNodeLinker->setNegation(true); dataBox->addIndividualSaturationProcessNodeLinker(indiProcNodeLinker); } } CSaturationIndividualReferenceLinking* satIndiRefLink = satCalcProcConstruct->getSaturationIndividualReferenceLinking(); if (satIndiRefLink) { CIndividualSaturationProcessNode* indiNode = (CIndividualSaturationProcessNode*)satIndiRefLink->getIndividualProcessNodeForConcept(); if (!indiNode->isInitialized()) { CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = indiNode->getIndividualSaturationProcessNodeLinker(); indiProcNodeLinker->setNegation(true); dataBox->addIndividualSaturationProcessNodeLinker(indiProcNodeLinker); } } satCalcProcConstruct = satCalcProcConstruct->getNextConstruct(); } if (additionalCalculatedCallback) { satCalcTask->addCallbackLinker(additionalCalculatedCallback); } satCalcTask->setSaturationIndividualsAnalysationObserver(approxSaturCalcJob->getSaturationIndividualsAnalysationObserver()); satCalcTask->setOccurrenceStatisticsCollectingAdapter(approxSaturCalcJob->getOccurrenceStatisticsCollectingAdapter()); satCalcTask->setConsistenceAdapter(approxSaturCalcJob->getSaturationTaskPreyingAdapter()); satCalcTask->setCalculationTaskType(CSatisfiableCalculationTask::CALCULATIONTABLEAUAPPROXIMATEDSATURATIONTASK); return satCalcTask; } CSatisfiableCalculationTask* CSatisfiableCalculationTaskFromCalculationJobGenerator::createSatisfiableCalculationTask(CConcreteOntology *ontology, CCalculationJob* calculationJob, CCallbackData* additionalCalculatedCallback) { CSatisfiableCalculationJob* satCalcJob = dynamic_cast(calculationJob); cint64 firstPossibleNewIndividualID = 1; if (satCalcJob) { CSatisfiableCalculationTask* baseTask = nullptr; bool lastConDesReapplication = false; bool clearIndiProcessingQueue = false; if (satCalcJob->getConsecutivelyCalculationJobInstantiation()) { baseTask = dynamic_cast(satCalcJob->getConsecutivelyCalculationJobInstantiation()); lastConDesReapplication = false; } if (!baseTask) { CConsistence* consistence = ontology->getConsistence(); CConsistenceTaskData* consTaskData = nullptr; if (consistence) { CConsistenceData* consData = consistence->getConsistenceModelData(); if (consData) { consTaskData = dynamic_cast(consData); } } if (consTaskData) { baseTask = consTaskData->getDeterministicSatisfiableTask(); if (satCalcJob->allowNonDeterministicSatisfiableCalculationContinuation()) { baseTask = consTaskData->getCompletionGraphCachedSatisfiableTask(); } else { clearIndiProcessingQueue = true; } firstPossibleNewIndividualID = consTaskData->getCompletionGraphCachedSatisfiableTask()->getProcessingDataBox()->getNextIndividualNodeID(false); lastConDesReapplication = baseTask != consTaskData->getCompletionGraphCachedSatisfiableTask(); } } return createSatisfiableCalculationTaskExtension(ontology,calculationJob,baseTask,lastConDesReapplication,clearIndiProcessingQueue, firstPossibleNewIndividualID,additionalCalculatedCallback); } CApproximatedSaturationCalculationJob* approxSaturCalcJob = dynamic_cast(calculationJob); if (approxSaturCalcJob) { CCalculationConfigurationExtension* calcConfig = approxSaturCalcJob->getCalculationConfiguration(); CSatisfiableCalculationTask* satCalcTask = nullptr; satCalcTask = createApproximatedSaturationCalculationTask(ontology,approxSaturCalcJob,additionalCalculatedCallback); return satCalcTask; } return nullptr; } CSatisfiableCalculationTask* CSatisfiableCalculationTaskFromCalculationJobGenerator::createSatisfiableCalculationTaskExtension(CCalculationJob* calculationJob, CSatisfiableCalculationTask* baseTask, bool lastConDesReapplication, bool clearIndiProcessingQueue, cint64 firstPossibleNewIndividualID, CCallbackData* additionalCalculatedCallback) { return createSatisfiableCalculationTaskExtension(calculationJob->getOntology(),calculationJob,baseTask,lastConDesReapplication,clearIndiProcessingQueue, firstPossibleNewIndividualID,additionalCalculatedCallback); } CSatisfiableCalculationTask* CSatisfiableCalculationTaskFromCalculationJobGenerator::createSatisfiableCalculationTaskExtension(CConcreteOntology *ontology, CCalculationJob* calculationJob, CSatisfiableCalculationTask* baseTask, bool lastConDesReapplication, bool clearIndiProcessingQueue, cint64 firstPossibleNewIndividualID, CCallbackData* additionalCalculatedCallback) { CSatisfiableCalculationJob* satCalcJob = dynamic_cast(calculationJob); if (satCalcJob) { bool requiresTaskCalc = false; CSatisfiableCalculationTask* satCalcTask = CObjectMemoryPoolAllocator::allocateAndConstructWithMemroyPool(mGenTaskHandleContext->getTaskHandleMemoryAllocationManager()); bool recreateNodesForIndividuals = false; if (clearIndiProcessingQueue) { bool avoidIndividualReprocessing = satCalcJob->getCalculationConfiguration()->isAvoidRepeatedIndividualProcessingActivated(); if (!avoidIndividualReprocessing) { clearIndiProcessingQueue = false; if (satCalcJob->getCalculationConfiguration()->isForceNodesRecreationForRepeatedIndividualProcessingActivated()) { baseTask = nullptr; if (!recreateNodesForIndividuals) { for (CSatisfiableCalculationConstruct* satCalcConstructIt = satCalcJob->getSatisfiableCalculationConstructs(); satCalcConstructIt && !clearIndiProcessingQueue; satCalcConstructIt = satCalcConstructIt->getNextConstruct()) { CIndividual* individual = satCalcConstructIt->getIndividual(); if (individual) { recreateNodesForIndividuals = true; } } } if (!recreateNodesForIndividuals) { if (calculationJob->getOntology()->getStructureSummary()->hasNominalOccurrence() || calculationJob->getOntology()->getTBox()->getUniversalConnectionNominalValueConcept()) { recreateNodesForIndividuals = true; } } } } else { bool confCompletionGraphCaching = satCalcJob->getCalculationConfiguration()->isCompletionGraphCachingActivated(); if (!confCompletionGraphCaching) { if (clearIndiProcessingQueue) { for (CSatisfiableCalculationConstruct* satCalcConstructIt = satCalcJob->getSatisfiableCalculationConstructs(); satCalcConstructIt && !clearIndiProcessingQueue; satCalcConstructIt = satCalcConstructIt->getNextConstruct()) { CIndividual* individual = satCalcConstructIt->getIndividual(); if (individual) { clearIndiProcessingQueue = false; } } } if (clearIndiProcessingQueue) { if (calculationJob->getOntology()->getStructureSummary()->hasNominalOccurrence() || calculationJob->getOntology()->getTBox()->getUniversalConnectionNominalValueConcept()) { clearIndiProcessingQueue = false; } } } } } if (baseTask) { satCalcTask->initUndependedSatisfiableCalculationTask(baseTask,satCalcJob->getCalculationConfiguration(),satCalcJob->getCalclulationStatisticsCollector(),mGenTaskHandleContext); } else { satCalcTask->initSatisfiableCalculationTask(ontology,satCalcJob->getCalculationConfiguration(),satCalcJob->getCalclulationStatisticsCollector(),mGenTaskHandleContext); } CProcessContext* procContext = satCalcTask->getProcessContext(mGenTaskHandleContext); if (baseTask) { CProcessTagger* processTagger = procContext->getUsedProcessTagger(); processTagger->incLocalizationTag(); } satCalcTask->setConsistenceAdapter(satCalcJob->getSatisfiableTaskPreyingAdapter()); satCalcTask->setClassificationMessageAdapter(satCalcJob->getSatisfiableClassificationMessageAdapter()); satCalcTask->setRealizationMarkedCandidatesMessageAdapter(satCalcJob->getRealizationMarkedCandidatesMessageAdapter()); satCalcTask->setSatisfiableTaskIncrementalConsistencyTestingAdapter(satCalcJob->getSatisfiableTaskIncrementalConsistencyTestingAdapter()); satCalcTask->setSatisfiableTaskIndividualDependenceTrackingAdapter(satCalcJob->getSatisfiableTaskIndividualDependenceTrackingAdapter()); satCalcTask->setPossibleAssertionCollectionAdapter(satCalcJob->getPossibleAssertionCollectionAdapter()); satCalcTask->setSatisfiableClassificationRoleMarkedMessageAdapter(satCalcJob->getSatisfiableClassificationRoleMarkedMessageAdapter()); satCalcTask->setSatisfiableAnswererSubsumptionMessageAdapter(satCalcJob->getSatisfiableAnswererSubsumptionMessageAdapter()); satCalcTask->setSatisfiableAnswererInstancePropagationMessageAdapter(satCalcJob->getSatisfiableAnswererInstancePropagationMessageAdapter()); satCalcTask->setSatisfiableAnswererBindingPropagationAdapter(satCalcJob->getSatisfiableAnswererBindingPropagationAdapter()); satCalcTask->setSatisfiablePossibleInstancesMergingAdapter(satCalcJob->getSatisfiablePossibleInstancesMergingAdapter()); satCalcTask->setSatisfiableRepresentativeBackendCacheUpdatingAdapter(satCalcJob->getSatisfiableRepresentativeBackendCacheUpdatingAdapter()); satCalcTask->setSatisfiableAnswererMaterializationAdapter(satCalcJob->getSatisfiableAnswererMaterializationAdapter()); satCalcTask->setCancellationAdapter(satCalcJob->getCancellationAdapter()); CProcessingDataBox* dataBox = satCalcTask->getProcessingDataBox(); if (baseTask) { dataBox->setProcessingOntology(ontology); } dataBox->setConstructedIndividualNode(nullptr); dataBox->setReapplicationLastConceptDesciptorOnLastIndividualNodeRequired(lastConDesReapplication); if (satCalcTask->getSatisfiableTaskIncrementalConsistencyTestingAdapter()) { CConcreteOntology* prevOntology = satCalcTask->getSatisfiableTaskIncrementalConsistencyTestingAdapter()->getPreviousConsistentOntology(); CSatisfiableCalculationTask* prevDetConsTask = nullptr; CSatisfiableCalculationTask* prevNondetConsTask = nullptr; CConsistence* prevConsistence = prevOntology->getConsistence(); CConsistenceTaskData* prevConsTaskData = nullptr; if (prevConsistence) { CConsistenceData* prevConsData = prevConsistence->getConsistenceModelData(); if (prevConsData) { prevConsTaskData = dynamic_cast(prevConsData); } } if (prevConsTaskData) { prevDetConsTask = prevConsTaskData->getDeterministicSatisfiableTask(); prevNondetConsTask = prevConsTaskData->getCompletionGraphCachedSatisfiableTask(); } if (prevDetConsTask) { CProcessTagger* prevProcessTagger = prevDetConsTask->getProcessingDataBox()->getProcessContext()->getUsedProcessTagger(); CProcessTagger* processTagger = procContext->getUsedProcessTagger(); processTagger->initProcessTagger(prevProcessTagger); processTagger->incLocalizationTag(); } if (prevNondetConsTask) { firstPossibleNewIndividualID = prevNondetConsTask->getProcessingDataBox()->getNextIndividualNodeID(false); } prevDetConsTask->getProcessingDataBox()->setIncrementalExpansionID(satCalcTask->getSatisfiableTaskIncrementalConsistencyTestingAdapter()->getIncrementalRevisionID()); } if (satCalcTask->getSatisfiableTaskIndividualDependenceTrackingAdapter()) { dataBox->setIndividualDependenceTrackingRequired(true); } CIndividualProcessNodeVector* indiNodeVec = dataBox->getIndividualProcessNodeVector(); if (clearIndiProcessingQueue) { dataBox->clearIndividualProcessingQueues(); } CIndividualUnsortedProcessingQueue* indiNodeQueue = dataBox->getIndividualImmediatelyProcessingQueue(true); CDependencyTrackPoint* independentBaseDepTrackPoint = dataBox->getBranchingTree(true)->getBaseDependencyNode(true)->getContinueDependencyTrackPoint(); CMemoryAllocationManager* memMan = procContext->getUsedMemoryAllocationManager(); firstPossibleNewIndividualID = qMax(firstPossibleNewIndividualID,indiNodeVec->getItemMaxIndex() + 1); cint64 baseIndiID = firstPossibleNewIndividualID; cint64 constructionIndiCount = 0; CIndividualVector* baseIndiVec = dataBox->getIndividualVector(true); CSatisfiableCalculationConstruct* satCalcConstruct = satCalcJob->getSatisfiableCalculationConstructs(); while (satCalcConstruct) { ++constructionIndiCount; CIndividual* individual = satCalcConstruct->getIndividual(); cint64 individualNodeID = baseIndiID+satCalcConstruct->getRelativeNewNodeID(); bool nominalIndiTriplesAssertions = false; if (!individual && satCalcConstruct->getIndividualID() >= 0 && satCalcConstruct->getIndividualID() <= baseIndiVec->getItemMaxIndex()) { individual = baseIndiVec->getData(satCalcConstruct->getIndividualID()); } if (!individual && satCalcConstruct->getIndividualID() >= 0) { individualNodeID = -satCalcConstruct->getIndividualID(); individual = CObjectAllocator::allocateAndConstruct(memMan); individual->initIndividual(-individualNodeID); individual->setTemporaryIndividual(true); baseIndiVec->setLocalData(-individualNodeID, individual); nominalIndiTriplesAssertions = true; } else if (individual) { individualNodeID = -(individual->getIndividualID()); nominalIndiTriplesAssertions = true; } else { cint64 fixedIndiID = satCalcConstruct->getIndividualID(); if (fixedIndiID >= 0) { individualNodeID = fixedIndiID; } } firstPossibleNewIndividualID = qMax(firstPossibleNewIndividualID,individualNodeID+1); CXSortedNegLinker* satConJobLinker = nullptr; CSatisfiableCalculationConceptConstruct* satConCalcConstuct = dynamic_cast(satCalcConstruct); if (satConCalcConstuct) { satConJobLinker = satConCalcConstuct->getConstructConceptLinker(); } CIndividualProcessNode* refIndiNode = indiNodeVec->getData(individualNodeID); // check whether individual is already processed if (satConJobLinker || !refIndiNode || !baseIndiVec || baseIndiVec->getData(-individualNodeID) != individual) { requiresTaskCalc = true; CIndividualProcessNode* indi = indiNodeVec->getLocalData(individualNodeID); CIndividualProcessNode* localIndi = indi; if (!localIndi) { localIndi = CObjectParameterizingAllocator< CIndividualProcessNode,CProcessContext* >::allocateAndConstructAndParameterize(memMan,procContext); localIndi->initDependencyTracker(independentBaseDepTrackPoint); if (refIndiNode) { while (refIndiNode->hasMergedIntoIndividualNodeID()) { cint64 corrIndiID = refIndiNode->getMergedIntoIndividualNodeID(); refIndiNode = indiNodeVec->getData(corrIndiID); individualNodeID = corrIndiID; } localIndi->initIndividualProcessNode(refIndiNode); localIndi->clearProcessingQueued(); localIndi->clearProcessingRestrictionFlags(CIndividualProcessNode::PRFCACHEDCOMPUTEDTYPESADDED); } else if (individual) { localIndi->setAssertionDataLinker(individual->getAssertionDataLinker()); localIndi->setAssertionConceptLinker(individual->getAssertionConceptLinker()); localIndi->setAssertionRoleLinker(individual->getAssertionRoleLinker()); localIndi->setReverseAssertionRoleLinker(individual->getReverseAssertionRoleLinker()); } localIndi->setIndividualNodeID(individualNodeID); if (individual) { if (!localIndi->getNominalIndividual()) { localIndi->setNominalIndividual(individual); } localIndi->setIndividualType(CIndividualProcessNode::NOMINALINDIVIDUALTYPE); } if (!individual || baseTask) { localIndi->addProcessingRestrictionFlags(CIndividualProcessNode::PRFINVALIDBLOCKINGORCACHING); } localIndi->setInitializingConceptLinker(nullptr); indiNodeVec->setLocalData(individualNodeID,localIndi); indiNodeQueue->insertIndiviudalProcessNode(localIndi); if (dataBox->getConstructedIndividualNode() == nullptr) { dataBox->setConstructedIndividualNode(localIndi); } } if (nominalIndiTriplesAssertions) { localIndi->setNominalIndividualTriplesAssertions(true); } CXSortedNegLinker* initConLinker = nullptr; while (satConJobLinker) { CXSortedNegLinker* tmpConLinker = CObjectAllocator< CXSortedNegLinker >::allocateAndConstruct(memMan); initConLinker = tmpConLinker->initNegLinker(satConJobLinker->getData(),satConJobLinker->getNegation(),initConLinker); satConJobLinker = satConJobLinker->getNext(); } localIndi->addInitializingConceptLinker(initConLinker); } satCalcConstruct = satCalcConstruct->getNextConstruct(); } if (recreateNodesForIndividuals) { CIndividualVector* indiVec = ontology->getABox()->getIndividualVector(false); QSet* activeIndiSet = ontology->getABox()->getActiveIndividualSet(false); cint64 maxTriplesIndexedIndiId = 0; cint64 maxABoxIndiId = 0; COntologyTriplesAssertionsAccessor* triplesAccessor = ontology->getOntologyTriplesData()->getTripleAssertionAccessor(); if (triplesAccessor) { maxTriplesIndexedIndiId = ontology->getOntologyTriplesData()->getTripleAssertionAccessor()->getMaxIndexedIndividualId(); } if (indiVec) { cint64 indiCount = indiVec->getItemCount(); for (cint64 i = 0; i < indiCount; ++i) { CIndividual* indi = indiVec->getData(i); if (indi && activeIndiSet->contains(indi)) { createIndividualNominalNodeForCalculationTask(ontology, indi, i, independentBaseDepTrackPoint, indiNodeQueue, indiNodeVec, procContext, memMan); } else if (i <= maxTriplesIndexedIndiId) { createIndividualNominalNodeForCalculationTask(ontology, indi, i, independentBaseDepTrackPoint, indiNodeQueue, indiNodeVec, procContext, memMan); } maxABoxIndiId = qMax(i, maxABoxIndiId); } } for (cint64 idx = maxABoxIndiId + 1; idx <= maxTriplesIndexedIndiId; ++idx) { createIndividualNominalNodeForCalculationTask(ontology, nullptr, idx, independentBaseDepTrackPoint, indiNodeQueue, indiNodeVec, procContext, memMan); } } dataBox->setFirstPossibleIndividualNodeID(firstPossibleNewIndividualID); dataBox->setMultipleConstructionIndividualNodes(constructionIndiCount > 1); if (additionalCalculatedCallback) { satCalcTask->addCallbackLinker(additionalCalculatedCallback); } return satCalcTask; } return nullptr; } bool CSatisfiableCalculationTaskFromCalculationJobGenerator::createIndividualNominalNodeForCalculationTask(CConcreteOntology *ontology, CIndividual* indi, cint64 i, CDependencyTrackPoint* independentBaseDepTrackPoint, CIndividualUnsortedProcessingQueue* indiNodeQueue, CIndividualProcessNodeVector* indiNodeVec, CProcessContext* procContext, CMemoryAllocationManager* memMan) { CIndividualProcessNode* indiNode = indiNodeVec->getData(-i); if (!indiNode) { indiNode = CObjectParameterizingAllocator< CIndividualProcessNode, CProcessContext* >::allocateAndConstructAndParameterize(memMan, procContext); indiNode->initDependencyTracker(independentBaseDepTrackPoint); if (indi) { indiNode->setAssertionDataLinker(indi->getAssertionDataLinker()); indiNode->setAssertionConceptLinker(indi->getAssertionConceptLinker()); indiNode->setAssertionRoleLinker(indi->getAssertionRoleLinker()); indiNode->setReverseAssertionRoleLinker(indi->getReverseAssertionRoleLinker()); } indiNode->setNominalIndividual(indi); indiNode->setIndividualNodeID(-i); indiNode->setIndividualType(CIndividualProcessNode::NOMINALINDIVIDUALTYPE); indiNodeVec->setLocalData(i, indiNode); indiNodeQueue->insertIndiviudalProcessNode(indiNode); return true; } return false; } }; // end namespace Generator }; // end namespace Reasoner }; // end namespace Konclude