Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser.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 "CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32
33 CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser::CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser() {
34 }
35
36
37
38 bool CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser::readCalculationConfig(CCalculationConfigurationExtension *config) {
39 if (config) {
40 return true;
41 }
42 return false;
43 }
44
45
46 CIndividualProcessNode* CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser::getCorrectedIndividualID(CIndividualProcessNode* baseIndiNode, CIndividualProcessNodeVector* indiNodeVec, bool* nondetMergedFlag) {
47 CIndividualProcessNode* indi = indiNodeVec->getData(baseIndiNode->getIndividualNodeID());
48 while (indi->hasMergedIntoIndividualNodeID()) {
49 if (nondetMergedFlag && *nondetMergedFlag == false) {
50 if (!indi->getMergedDependencyTrackPoint() || indi->getMergedDependencyTrackPoint()->getBranchingTag() > 0) {
51 *nondetMergedFlag = true;
52 }
53 }
54 indi = indiNodeVec->getData(indi->getMergedIntoIndividualNodeID());
55 }
56 return indi;
57 }
58
59
60
61
62
63 CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser* CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser::appendVariableBindingsPropagation(CVariableBindingPath* varBindPath, CVARIABLEBINDINGMESSAGELIST<CVariable*>*& variablesList,
64 CVARIABLEBINDINGMESSAGELIST<CAnsweringMessageDataVariableBindingPropagationsData*>*& individualBindingList, cint64 maxDetBranchTag, CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
65
66 if (!variablesList) {
67 variablesList = CObjectParameterizingAllocator< CVARIABLEBINDINGMESSAGELIST<CVariable*>, CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan, mTmpContext);
68 for (CVariableBindingDescriptor* varBindDesIt = varBindPath->getVariableBindingDescriptorLinker(); varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
69 CVariableBinding* varBind = varBindDesIt->getVariableBinding();
70 CVariable* variable = varBind->getBindedVariable();
71 variablesList->append(variable);
72 }
73 }
74
75 CProcessingDataBox* processingDataBox = statCalcTask->getProcessingDataBox();
76 CIndividualProcessNodeVector* indiNodeVec = processingDataBox->getIndividualProcessNodeVector();
77
78
79
80 CPROCESSINGLIST<CIndividualReference*>* nonDetMergedIndiBindingsVecList = nullptr;
81
82 CIndividualReference* indiBindingsVec = CObjectAllocator< CIndividualReference >::allocateAndConstructArray(mTempMemAllocMan, variablesList->count());
83 cint64 nextIndiBindingPos = 0;
84
85 bool varNonDeterministicallyDerived = false;
86 for (CVariableBindingDescriptor* varBindDesIt = varBindPath->getVariableBindingDescriptorLinker(); varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
87 CVariableBinding* varBind = varBindDesIt->getVariableBinding();
88 CVariable* variable = varBind->getBindedVariable();
89 CIndividualProcessNode* bindedIndiNode = varBind->getBindedIndividual();
90 bool nondeterMerged = false;
91 bindedIndiNode = getCorrectedIndividualID(bindedIndiNode, indiNodeVec, &nondeterMerged);
92 if (nondeterMerged) {
93 varNonDeterministicallyDerived = true;
94 }
95 CIndividualReference indiRef = bindedIndiNode->getNominalIndividual();
96 if (bindedIndiNode->getNominalIndividual() && bindedIndiNode->getNominalIndividual()->isTemporaryIndividual()) {
97 indiRef = bindedIndiNode->getNominalIndividual()->getIndividualID();
98 }
99 if (nonDetMergedIndiBindingsVecList) {
100 for (CPROCESSINGLIST<CIndividualReference*>::const_iterator it = nonDetMergedIndiBindingsVecList->constBegin(), itEnd = nonDetMergedIndiBindingsVecList->constEnd(); it != itEnd; ++it) {
101 CIndividualReference* mergedIndiBindingsVec = (*it);
102 mergedIndiBindingsVec[nextIndiBindingPos] = indiRef;
103 }
104 } else {
105 indiBindingsVec[nextIndiBindingPos] = indiRef;
106 }
107 CDependencyTrackPoint* varDepTrackPoint = varBind->getDependencyTrackPoint();
108 if (varDepTrackPoint) {
109 if (varDepTrackPoint->getBranchingTag() > maxDetBranchTag) {
110 varNonDeterministicallyDerived = true;
111 }
112 } else {
113 varNonDeterministicallyDerived = true;
114 }
115
116 CIndividualMergingHash* indiMergHash = bindedIndiNode->getIndividualMergingHash(false);
117 if (indiMergHash) {
118 for (CIndividualMergingHash::const_iterator it = indiMergHash->constBegin(), itEnd = indiMergHash->constEnd(); it != itEnd; ++it) {
119 if (it.value().isMergedWithIndividual()) {
120 cint64 mergedIndiId = it.key();
121 CDependencyTrackPoint* mergeDepTrackPoint = it.value().getDependencyTrackPoint();
122 bool nondeterMerged = false;
123 if (!mergeDepTrackPoint || mergeDepTrackPoint->getBranchingTag() > maxDetBranchTag) {
124 nondeterMerged = true;
125 }
126 if (nondeterMerged) {
127 if (!nonDetMergedIndiBindingsVecList) {
128 nonDetMergedIndiBindingsVecList = CObjectParameterizingAllocator< CPROCESSINGLIST<CIndividualReference*>, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
129 nonDetMergedIndiBindingsVecList->append(indiBindingsVec);
130 }
131
132 CPROCESSINGLIST<CIndividualReference*>::iterator it = nonDetMergedIndiBindingsVecList->begin();
133 for (cint64 i = nonDetMergedIndiBindingsVecList->count(); i > 0; --i) {
134 CIndividualReference* nextIndiBindingsVec = *it;
135 ++it;
136 CIndividualReference* newIndiBindingsVec = CObjectAllocator< CIndividualReference >::allocateAndConstructArray(mTempMemAllocMan, variablesList->count());
137 for (cint64 i = 0; i < nextIndiBindingPos; ++i) {
138 newIndiBindingsVec[i] = nextIndiBindingsVec[i];
139 }
140 CIndividualProcessNode* mergedIndiNode = indiNodeVec->getData(-mergedIndiId);
141 CIndividualReference mergedIndiRef = mergedIndiNode->getNominalIndividual();
142 if (mergedIndiNode->getNominalIndividual() && mergedIndiNode->getNominalIndividual()->isTemporaryIndividual()) {
143 mergedIndiRef = mergedIndiNode->getNominalIndividual()->getIndividualID();
144 }
145 newIndiBindingsVec[nextIndiBindingPos] = mergedIndiRef;
146 nonDetMergedIndiBindingsVecList->append(newIndiBindingsVec);
147 }
148 }
149 }
150 }
151 }
152 nextIndiBindingPos++;
153
154 }
155
156 CAnsweringMessageDataVariableBindingPropagationsData* dataVariableBindingPropagationData = CObjectParameterizingAllocator< CAnsweringMessageDataVariableBindingPropagationsData, CContext* >::allocateAndConstruct(mTempMemAllocMan);
157 dataVariableBindingPropagationData->initBindingPropagationsData(varNonDeterministicallyDerived, indiBindingsVec);
158 if (!individualBindingList) {
159 individualBindingList = CObjectParameterizingAllocator< CVARIABLEBINDINGMESSAGELIST<CAnsweringMessageDataVariableBindingPropagationsData*>, CContext* >::allocateAndConstructAndParameterize(mTempMemAllocMan, mTmpContext);
160 }
161 individualBindingList->append(dataVariableBindingPropagationData);
162
163
164 if (nonDetMergedIndiBindingsVecList) {
165 CPROCESSINGLIST<CIndividualReference*>::const_iterator it = nonDetMergedIndiBindingsVecList->constBegin(), itEnd = nonDetMergedIndiBindingsVecList->constEnd();
166 for (++it; it != itEnd; ++it) {
167 CIndividualReference* mergedIndiBindingsVec = (*it);
168 CAnsweringMessageDataVariableBindingPropagationsData* mergedDataVariableBindingPropagationData = CObjectParameterizingAllocator< CAnsweringMessageDataVariableBindingPropagationsData, CContext* >::allocateAndConstruct(mTempMemAllocMan);
169 mergedDataVariableBindingPropagationData->initBindingPropagationsData(true, mergedIndiBindingsVec);
170 individualBindingList->append(mergedDataVariableBindingPropagationData);
171 }
172 }
173
174 return this;
175 }
176
177
178
179
180
181 bool CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser::analyseSatisfiableTask(CSatisfiableCalculationTask* statCalcTask, CCalculationAlgorithmContext* calcAlgContext) {
182 mStatCalcTask = statCalcTask;
183 CSatisfiableTaskAnswererBindingPropagationAdapter* answererConceptMarkedAdapter = statCalcTask->getSatisfiableAnswererBindingPropagationAdapter();
184 if (answererConceptMarkedAdapter) {
185 CAnsweringMessageDataObserver* answererMessPropagationObserver = answererConceptMarkedAdapter->getAnswererMessageDataObserver();
186 CAnsweringMessageData* subsumMessageDataLinker = nullptr;
187 CAnsweringMessageData* possSubsumMessageDataLinker = nullptr;
188
189
190 CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
191 CTaskHandleMemoryAllocationManager* taskMemMan = calcAlgContext->getTemporaryMemoryAllocationManager();
192 CConcept* testingConcept = answererConceptMarkedAdapter->getTestingConcept();
193 CConcept* finalPropagationConcept = answererConceptMarkedAdapter->getPropagationFinalizationConcept();
194
195
196
197 CAnsweringHandler* answeringHandler = answererConceptMarkedAdapter->getAnsweringHandler();
198 CConcreteOntology* testOntology = answererConceptMarkedAdapter->getTestingOntology();
199 CProcessingDataBox* processingDataBox = statCalcTask->getProcessingDataBox();
200 CIndividualProcessNodeVector* indiNodeVec = processingDataBox->getIndividualProcessNodeVector();
201
202 cint64 maxDetBranchTag = processingDataBox->getMaximumDeterministicBranchTag();
203
204
205 CMarkerIndividualNodeHash* markerIndiNodeHash = statCalcTask->getProcessingDataBox()->getMarkerIndividualNodeHash(false);
206
207
208 if (testOntology && testingConcept && finalPropagationConcept && markerIndiNodeHash) {
209
210 CXNegLinker<CIndividualProcessNode*>* indiProcNodeLinker = markerIndiNodeHash->getMarkerIndividualNodeLinker(finalPropagationConcept);
211
212
213
214 CMemoryPoolContainer memPoolCon;
215 CTaskMemoryPoolAllocationManager classMessMemManCreaterMemMan(&memPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
216 mTempMemAllocMan = CObjectAllocator<CTaskMemoryPoolAllocationManager>::allocateAndConstruct(&classMessMemManCreaterMemMan);
217 mTempMemAllocMan->initTaskMemoryPoolAllocationManager(&memPoolCon,calcAlgContext->getTemporaryMemoryAllocationManager());
218 mTmpContext = CObjectParameterizingAllocator< CContextBase,CMemoryAllocationManager* >::allocateAndConstructAndParameterize(mTempMemAllocMan,mTempMemAllocMan);
219
220 CVARIABLEBINDINGMESSAGELIST<CVariable*>* variablesList = nullptr;
221 CVARIABLEBINDINGMESSAGELIST<CAnsweringMessageDataVariableBindingPropagationsData*>* individualBindingList = nullptr;
222 cint64 indiCount = 0;
223
224 for (CXNegLinker<CIndividualProcessNode*>* indiProcNodeLinkerIt = indiProcNodeLinker; indiProcNodeLinkerIt; indiProcNodeLinkerIt = indiProcNodeLinkerIt->getNext()) {
225 ++indiCount;
226 CIndividualProcessNode* indiProcNode = indiProcNodeLinkerIt->getData();
227 bool nonDeterministic = indiProcNodeLinkerIt->isNegated();
228
229 indiProcNode = getCorrectedIndividualID(indiProcNode, indiNodeVec, &nonDeterministic);
230 CConceptVariableBindingPathSetHash* conVarBindPathSetHash = indiProcNode->getConceptVariableBindingPathSetHash(false);
231 if (conVarBindPathSetHash) {
232 CVariableBindingPathSet* varBindPathSet = conVarBindPathSetHash->getVariableBindingPathSet(finalPropagationConcept, false);
233
234 CVariableBindingPathMap* varBindPathMap = varBindPathSet->getVariableBindingPathMap();
235 for (CVariableBindingPathMap::iterator it = varBindPathMap->begin(), itEnd = varBindPathMap->end(); it != itEnd; ++it) {
236 CVariableBindingPathMapData& varBindPathData = it.value();
237 CVariableBindingPathDescriptor* varBindPathDes = varBindPathData.getVariableBindingPathDescriptor();
238 CVariableBindingPath* varBindPath = varBindPathDes->getVariableBindingPath();
239
240 appendVariableBindingsPropagation(varBindPath, variablesList, individualBindingList, maxDetBranchTag, statCalcTask, calcAlgContext);
241
242 }
243 }
244
245
246
247 CConceptRepresentativePropagationSetHash* repPropSetHash = indiProcNode->getConceptRepresentativePropagationSetHash(false);
248 if (repPropSetHash) {
249 CRepresentativePropagationSet* repPropSet = repPropSetHash->getRepresentativePropagationSet(finalPropagationConcept, false);
250
251
252 if (repPropSet) {
253
254 CRepresentativePropagationDescriptor* outRepPropDes = repPropSet->getOutgoingRepresentativePropagationDescriptorLinker();
255 if (outRepPropDes) {
256 CRepresentativeVariableBindingPathSetData* repVarBindPathSetData = outRepPropDes->getRepresentativeVariableBindingPathSetData();
257 if (repVarBindPathSetData) {
258 CRepresentativeVariableBindingPathSetMigrateData* repVarBindPathSetMigData = repVarBindPathSetData->getMigrateData(false);
259 if (repVarBindPathSetMigData) {
260 CRepresentativeVariableBindingPathMap* repVarBindPathSetMap = repVarBindPathSetMigData->getRepresentativeVariableBindingPathMap();
261
262 for (CRepresentativeVariableBindingPathMap::const_iterator it = repVarBindPathSetMap->constBegin(), itEnd = repVarBindPathSetMap->constEnd(); it != itEnd; ++it) {
263 const CRepresentativeVariableBindingPathMapData& varBindPathData = it.value();
264 CVariableBindingPath* varBindPath = varBindPathData.getVariableBindingPath();
265
266 appendVariableBindingsPropagation(varBindPath, variablesList, individualBindingList, maxDetBranchTag, statCalcTask, calcAlgContext);
267 }
268 }
269 }
270 }
271 }
272 }
273 }
274
275 CAnsweringMessageDataVariableBindingPropagations* variableBindingPropagationData = CObjectAllocator<CAnsweringMessageDataVariableBindingPropagations>::allocateAndConstruct(mTempMemAllocMan);
276 variableBindingPropagationData->initAnsweringVariableBindingMessageData(finalPropagationConcept, variablesList, individualBindingList);
277 answererMessPropagationObserver->sendMessage(answeringHandler, variableBindingPropagationData, memPoolCon.takeMemoryPools());
278
279 return true;
280
281 }
282 }
283 return false;
284 }
285
286
287
288
289 }; // end namespace Algorithm
290
291 }; // end namespace Kernel
292
293 }; // end namespace Reasoner
294
295 }; // end namespace Konclude