Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CIncrementalCompletionGraphCompatibleExpansionHandler.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CIncrementalCompletionGraphCompatibleExpansionHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32 CIncrementalCompletionGraphCompatibleExpansionHandler::CIncrementalCompletionGraphCompatibleExpansionHandler() {
33 }
34
35
36 CIncrementalCompletionGraphCompatibleExpansionHandler::~CIncrementalCompletionGraphCompatibleExpansionHandler() {
37 }
38
39
40
41 CSatisfiableCalculationTask* CIncrementalCompletionGraphCompatibleExpansionHandler::getPreviousDeterministicCompletionGraphTask(CCalculationAlgorithmContext* calcAlgContext) {
42 CSatisfiableTaskIncrementalConsistencyTestingAdapter* incConsTestAdapter = calcAlgContext->getSatisfiableCalculationTask()->getSatisfiableTaskIncrementalConsistencyTestingAdapter();
43 if (incConsTestAdapter) {
44 CConcreteOntology* prevConsOntology = incConsTestAdapter->getPreviousConsistentOntology();
45 if (prevConsOntology) {
46 CConsistence* consistence = prevConsOntology->getConsistence();
47 if (consistence) {
48 CConsistenceData* consData = consistence->getConsistenceModelData();
49 if (consData) {
50 CConsistenceTaskData* consTaskData = dynamic_cast<CConsistenceTaskData*>(consData);
51 if (consTaskData) {
52 CSatisfiableCalculationTask* prevCompGraphCalcTask = consTaskData->getDeterministicSatisfiableTask();
53 return prevCompGraphCalcTask;
54 }
55 }
56 }
57 }
58 }
59 return nullptr;
60 }
61
62 CSatisfiableCalculationTask* CIncrementalCompletionGraphCompatibleExpansionHandler::getPreviousNondeterministicCompletionGraphTask(CCalculationAlgorithmContext* calcAlgContext) {
63 CSatisfiableTaskIncrementalConsistencyTestingAdapter* incConsTestAdapter = calcAlgContext->getSatisfiableCalculationTask()->getSatisfiableTaskIncrementalConsistencyTestingAdapter();
64 if (incConsTestAdapter) {
65 CConcreteOntology* prevConsOntology = incConsTestAdapter->getPreviousConsistentOntology();
66 if (prevConsOntology) {
67 CConsistence* consistence = prevConsOntology->getConsistence();
68 if (consistence) {
69 CConsistenceData* consData = consistence->getConsistenceModelData();
70 if (consData) {
71 CConsistenceTaskData* consTaskData = dynamic_cast<CConsistenceTaskData*>(consData);
72 if (consTaskData) {
73 CSatisfiableCalculationTask* prevCompGraphCalcTask = consTaskData->getCompletionGraphCachedSatisfiableTask();
74 return prevCompGraphCalcTask;
75 }
76 }
77 }
78 }
79 }
80 return nullptr;
81 }
82
83
84 CIndividualProcessNode* CIncrementalCompletionGraphCompatibleExpansionHandler::getPreviousDeterministicCompletionGraphCorrespondingIndividualNode(CIndividualProcessNode* individualNode, CCalculationAlgorithmContext* calcAlgContext) {
85 CIndividualProcessNode* prevIndiNode = nullptr;
86 CIndividualNodeIncrementalExpansionData* incExpData = individualNode->getIncrementalExpansionData(false);
87 if (!incExpData || !incExpData->isPreviousCompletionGraphCorrespondenceIndividualNodeLoaded()) {
88 CIndividualNodeIncrementalExpansionData* locIncExpData = individualNode->getIncrementalExpansionData(true);
89 CSatisfiableCalculationTask* prevCompGraphCalcTask = getPreviousDeterministicCompletionGraphTask(calcAlgContext);
90 if (prevCompGraphCalcTask) {
91 CIndividualProcessNodeVector* prevCompGraphProcNodeVec = prevCompGraphCalcTask->getProcessingDataBox()->getIndividualProcessNodeVector();
92 if (prevCompGraphProcNodeVec) {
93 prevIndiNode = prevCompGraphProcNodeVec->getData(individualNode->getIndividualNodeID());
94 }
95 }
96
97 locIncExpData->setPreviousCompletionGraphCorrespondenceIndividualNode(prevIndiNode);
98 locIncExpData->setPreviousCompletionGraphCorrespondenceIndividualNodeLoaded(true);
99 incExpData = locIncExpData;
100 }
101 prevIndiNode = incExpData->getPreviousCompletionGraphCorrespondenceIndividualNode();
102 return prevIndiNode;
103 }
104
105
106 bool CIncrementalCompletionGraphCompatibleExpansionHandler::isIndividualNodePreviousCompletionGraphCompatible(CIndividualProcessNode* individualNode, CCalculationAlgorithmContext* calcAlgContext) {
107 CIndividualNodeIncrementalExpansionData* incExpData = individualNode->getIncrementalExpansionData(false);
108 CReapplyConceptLabelSet* conSet = individualNode->getReapplyConceptLabelSet(false);
109 CConceptDescriptor* lastConDes = conSet->getAddingSortedConceptDescriptionLinker();
110 CConceptDescriptor* lastCheckedConDes = incExpData->getLastCompatibleCheckedConceptDescriptor();
111 bool compatible = incExpData->isPreviousCompletionGraphCompatible();
112 if (!individualNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED) && lastCheckedConDes != lastConDes) {
113 // recheck compatibility
114 CIndividualProcessNode* prevIndiNode = getPreviousDeterministicCompletionGraphCorrespondingIndividualNode(individualNode,calcAlgContext);
115 if (prevIndiNode && !prevIndiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED)) {
116 bool incompatibleConcepts = false;
117 CReapplyConceptLabelSet* prevConSet = prevIndiNode->getReapplyConceptLabelSet(false);
118 if (conSet->getConceptSignatureValue() == prevConSet->getConceptSignatureValue() && prevConSet->getConceptCount() == conSet->getConceptCount()) {
119 CReapplyConceptLabelSetIterator conSetIt = conSet->getConceptLabelSetIterator(true);
120 CReapplyConceptLabelSetIterator prevConSetIt = prevConSet->getConceptLabelSetIterator(true);
121 while (conSetIt.hasNext() && prevConSetIt.hasNext()) {
122 CConceptDescriptor* conDes = conSetIt.getConceptDescriptor();
123 CConceptDescriptor* prevConDes = prevConSetIt.getConceptDescriptor();
124 if (conDes->getConcept() != prevConDes->getConcept() || conDes->isNegated() != prevConDes->isNegated()) {
125 incompatibleConcepts = true;
126 }
127 conSetIt.moveNext();
128 prevConSetIt.moveNext();
129 }
130 } else {
131 incompatibleConcepts = true;
132 }
133 if (!incompatibleConcepts) {
134 compatible = true;
135 }
136 }
137 CIndividualNodeIncrementalExpansionData* locIncExpData = individualNode->getIncrementalExpansionData(true);
138 locIncExpData->setPreviousCompletionGraphCompatible(compatible);
139 locIncExpData->setLastCompatibleCheckedConceptDescriptor(lastConDes);
140 }
141 return compatible;
142 }
143
144
145
146
147 }; // end namespace Algorithm
148
149 }; // end namespace Kernel
150
151 }; // end namespace Reasoner
152
153 }; // end namespace Konclude