Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CConceptNominalSchemaGroundingHandler.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 "CConceptNominalSchemaGroundingHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32 CConceptNominalSchemaGroundingHandler::CConceptNominalSchemaGroundingHandler() {
33 mConfReuseGroundedNominalSchemaConcepts = true;
34 }
35
36
37
38 CSortedNegLinker<CConcept*>* CConceptNominalSchemaGroundingHandler::getGroundingConceptLinker(CIndividualProcessNode* processNode, CPropagationBindingSet* propBindSet, CConcept* concept, bool negated, CPROCESSINGHASH<CConcept*,CPropagationBindingDescriptor*>*& groundedConPropBindDesHash, CPROCESSINGHASH<CVariable*,CPropagationBindingDescriptor*>*& additionalPropBindDesHash, CCalculationAlgorithmContext* calcAlgContext) {
39 CSortedNegLinker<CConcept*>* newLinker = nullptr;
40
41 mDataBox = calcAlgContext->getUsedProcessingDataBox();
42 CProcessContext* context = calcAlgContext->getUsedProcessContext();
43 mMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
44 CMBox* mBox = mDataBox->getOntology()->getDataBoxes()->getMBox();
45 mTBox = mDataBox->getOntology()->getDataBoxes()->getTBox();
46 mConceptVec = mDataBox->getExtendedConceptVector(false);
47 mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(false);
48 CNominalSchemaTemplateVector* nomSchVec = mBox->getNominalSchemaTemplateVector(false);
49 mLocalizedExtensions = false;
50
51 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair> nominalSchemaVarBindedNominalHash(calcAlgContext->getUsedTaskProcessorContext());
52 CPROCESSINGSET<CConcept*>* allNominalConceptSet = nullptr;
53
54 cint64 nomSchTemplID = concept->getParameter();
55
56
57 if (nomSchVec) {
58 CNominalSchemaTemplate* nomSchTempl = nomSchVec->getData(nomSchTemplID);
59 CConcept* templateConcept = nomSchTempl->getTemplateConcept();
60 CBOXHASH<CConcept*,CConcept*>* templateConceptNomSchVarHash = nomSchTempl->getTemplateConceptNominalSchemaConceptHash();
61 CBOXSET<CConcept*>* templateConceptNomSchVarSet = nomSchTempl->getNominalSchemaConceptSet();
62
63 CPropagationBindingMap* propBindMap = propBindSet->getPropagationBindingMap();
64 for (CPropagationBindingMap::iterator it = propBindMap->begin(), itEnd = propBindMap->end(); it != itEnd; ++it) {
65 CPropagationBindingMapData& propBindData = it.value();
66 CPropagationBindingDescriptor* propBindDes = propBindData.getPropagationBindingDescriptor();
67 CPropagationBinding* propBinding = propBindDes->getPropagationBinding();
68 CVariable* variable = propBinding->getBindedVariable();
69 CIndividualProcessNode* bindedIndiNode = propBinding->getBindedIndividual();
70 if (variable->isNominalVariable()) {
71 CConcept* nomSchVarConcept = variable->getNominalVariableConcept();
72 if (templateConceptNomSchVarSet->contains(nomSchVarConcept)) {
73 CConcept* nominalConcept = getNominalConcept(bindedIndiNode,true,calcAlgContext);
74 if (nominalConcept) {
75 nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,propBindDes));
76 }
77 }
78 }
79 }
80
81 for (CBOXSET<CConcept*>::iterator it = templateConceptNomSchVarSet->begin(), itEnd = templateConceptNomSchVarSet->end(); it != itEnd; ++it) {
82 CConcept* nomSchVarConcept = *it;
83 if (!nominalSchemaVarBindedNominalHash.contains(nomSchVarConcept)) {
84 collectAllNominalConcepts(allNominalConceptSet,calcAlgContext);
85 for (CPROCESSINGSET<CConcept*>::const_iterator nomIt = allNominalConceptSet->constBegin(), nomItEnd = allNominalConceptSet->constEnd(); nomIt != nomItEnd; ++nomIt) {
86 CConcept* nominalConcept(*nomIt);
87 nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
88 }
89 }
90 }
91
92 newLinker = createNominalSchemaGroundingConcepts(processNode,nomSchTempl->getTemplateConcept(),negated,&nominalSchemaVarBindedNominalHash,groundedConPropBindDesHash,nomSchTempl,calcAlgContext);
93
94 if (newLinker) {
95 if (!additionalPropBindDesHash) {
96 additionalPropBindDesHash = CObjectParameterizingAllocator< CPROCESSINGHASH<CVariable*,CPropagationBindingDescriptor*>,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());;
97 }
98 for (CPropagationBindingMap::iterator it = propBindMap->begin(), itEnd = propBindMap->end(); it != itEnd; ++it) {
99 CPropagationBindingMapData& propBindData = it.value();
100 CPropagationBindingDescriptor* propBindDes = propBindData.getPropagationBindingDescriptor();
101 CPropagationBinding* propBinding = propBindDes->getPropagationBinding();
102 CVariable* variable = propBinding->getBindedVariable();
103 additionalPropBindDesHash->insert(variable,propBindDes);
104 }
105
106 }
107 }
108
109 return newLinker;
110 }
111
112
113 void CConceptNominalSchemaGroundingHandler::collectAllNominalConcepts(CPROCESSINGSET<CConcept*>*& allNominalConceptSet, CCalculationAlgorithmContext* calcAlgContext) {
114 if (!allNominalConceptSet) {
115 allNominalConceptSet = CObjectParameterizingAllocator< CPROCESSINGSET<CConcept*>,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
116 CIndividualVector* individualVector = calcAlgContext->getProcessingDataBox()->getOntology()->getABox()->getIndividualVector(false);
117 cint64 individualCount = 0;
118 if (individualVector) {
119 individualCount = individualVector->getItemCount();
120 // TODO: only active individuals
121 for (cint64 i = 0; i < individualCount; ++i) {
122 CIndividual* individual = individualVector->getData(i);
123 for (CConceptAssertionLinker* assConLinkerIt = individual->getAssertionConceptLinker(); assConLinkerIt; assConLinkerIt = assConLinkerIt->getNext()) {
124 CConcept* assCon = assConLinkerIt->getData();
125 bool assConNegation = assConLinkerIt->isNegated();
126 cint64 assConOpCode = assCon->getOperatorCode();
127 if (!assConNegation && assConOpCode == CCNOMINAL) {
128 allNominalConceptSet->insert(assCon);
129 }
130 }
131 }
132 }
133 }
134 }
135
136
137 CConcept* CConceptNominalSchemaGroundingHandler::getNominalConcept(CIndividualProcessNode* processNode, bool forceNotPruned, CCalculationAlgorithmContext* calcAlgContext) {
138 CIndividualProcessNodeVector* mIndiVector = calcAlgContext->getUsedProcessingDataBox()->getIndividualProcessNodeVector();
139 CIndividualProcessNode* indiNode = mIndiVector->getData(processNode->getIndividualNodeID());
140 //while (indiNode->getIndividualID() != indiNode->getMergedIntoIndividualNodeID()) {
141 // indiNode = mIndiVector->getData(indiNode->getMergedIntoIndividualNodeID());
142 //}
143 CConcept* nomConcept = nullptr;
144 if (!forceNotPruned || !indiNode->hasPartialProcessingRestrictionFlags(CIndividualProcessNode::PRFPURGEDBLOCKED)) {
145 CIndividual* nomIndi = indiNode->getNominalIndividual();
146 CConceptAssertionLinker* assLinker = nomIndi->getAssertionConceptLinker();
147 while (assLinker && !nomConcept) {
148 CConcept* assConcept = assLinker->getData();
149 bool assNegation = assLinker->isNegated();
150 if (!assNegation && assConcept->getOperatorCode() == CCNOMINAL) {
151 nomConcept = assConcept;
152 }
153 assLinker = assLinker->getNext();
154 }
155 }
156 return nomConcept;
157 }
158
159
160
161
162 void CConceptNominalSchemaGroundingHandler::addConceptOperand(CConcept* concept, CConcept* opConcept, bool negated) {
163 CSortedNegLinker<CConcept*>* opConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
164 opConLinker->init(opConcept,negated);
165 concept->addOperandLinker(opConLinker);
166 concept->incOperandCount();
167 }
168
169
170 CConcept* CConceptNominalSchemaGroundingHandler::createNominalSchemaConceptCopy(CConcept* concept) {
171 CConcept* conceptCopy = CObjectAllocator< CConcept >::allocateAndConstruct(mMemMan);
172 conceptCopy->initConceptCopy(concept);
173 conceptCopy->setOperandCount(0);
174 conceptCopy->setConceptTag(mConceptVec->getItemCount());
175 mConceptVec->setData(conceptCopy->getConceptTag(),conceptCopy);
176 return conceptCopy;
177 }
178
179
180 CConcept* CConceptNominalSchemaGroundingHandler::createGroundedNominalSchemaConcept(CConcept* concept, CBOXHASH<CConcept*,CConcept*>* templConNomSchConHash, QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >* nomSchConIndividualItHash, CCalculationAlgorithmContext* calcAlgContext) {
181
182 if (templConNomSchConHash->contains(concept)) {
183
184 cint64 opCode = concept->getOperatorCode();
185 if (opCode == CCNOMVAR) {
186 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator nomVarIt = nomSchConIndividualItHash->value(concept);
187 CConcept* nominalConcept = nomVarIt.value().first;
188 return nominalConcept;
189 }
190
191
192 if (mConfReuseGroundedNominalSchemaConcepts && mReplaceHash) {
193 CConceptNominalSchemaGroundingData mHashedTestData(calcAlgContext->getUsedTaskProcessorContext());
194 mHashedTestData.setGroundingConcept(concept);
195 CBOXHASH<CConcept*,CConcept*>::const_iterator it = templConNomSchConHash->constFind(concept), itEnd = templConNomSchConHash->constEnd();
196 while (it != itEnd && it.key() == concept) {
197 CConcept* nomSchemConcept = *it;
198 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator nomVarIt = nomSchConIndividualItHash->value(nomSchemConcept);
199 CConcept* indiConcept = nomVarIt.value().first;
200 mHashedTestData.addBindedNominalSchemaConcept(indiConcept);
201 ++it;
202 }
203 CConceptNominalSchemaGroundingData* replaceConData = mReplaceHash->value(CConceptNominalSchemaGroundingHasher(&mHashedTestData),nullptr);
204 if (replaceConData) {
205 return replaceConData->getGroundedConcept();
206 }
207 }
208
209 forceExtensionLocalisation(calcAlgContext);
210 CConcept* copiedConcept = createNominalSchemaConceptCopy(concept);
211
212 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
213 CConcept* opConcept = opConLinkerIt->getData();
214 bool opConNegation = opConLinkerIt->isNegated();
215
216 CConcept* newOpConcept = createGroundedNominalSchemaConcept(opConcept,templConNomSchConHash,nomSchConIndividualItHash,calcAlgContext);
217 addConceptOperand(copiedConcept,newOpConcept,opConNegation);
218 }
219
220 if (mConfReuseGroundedNominalSchemaConcepts) {
221 CConceptNominalSchemaGroundingData* mHashedTestData = CObjectParameterizingAllocator< CConceptNominalSchemaGroundingData,CProcessContext* >::allocateAndConstructAndParameterize(mMemMan,calcAlgContext->getUsedProcessContext());
222 mHashedTestData->setGroundingConcept(concept);
223 CBOXHASH<CConcept*,CConcept*>::const_iterator it = templConNomSchConHash->constFind(concept), itEnd = templConNomSchConHash->constEnd();
224 while (it != itEnd && it.key() == concept) {
225 CConcept* nomSchemConcept = *it;
226 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator nomVarIt = nomSchConIndividualItHash->value(nomSchemConcept);
227 CConcept* indiConcept = nomVarIt.value().first;
228 mHashedTestData->addBindedNominalSchemaConcept(indiConcept);
229 ++it;
230 }
231 mHashedTestData->setGroundedConcept(copiedConcept);
232 mReplaceHash->insert(CConceptNominalSchemaGroundingHasher(mHashedTestData),mHashedTestData);
233 }
234
235 return copiedConcept;
236 } else {
237 return concept;
238 }
239
240 }
241
242
243 bool CConceptNominalSchemaGroundingHandler::forceExtensionLocalisation(CCalculationAlgorithmContext* calcAlgContext) {
244 if (!mLocalizedExtensions) {
245 mLocalizedExtensions = true;
246 mConceptVec = mDataBox->getExtendedConceptVector(true);
247 mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(true);
248 return true;
249 }
250 return false;
251 }
252
253
254 CSortedNegLinker<CConcept*>* CConceptNominalSchemaGroundingHandler::createNominalSchemaGroundingConcepts(CIndividualProcessNode* indiProcessNode, CConcept* concept, bool negated, CPROCESSINGHASH<CConcept*, TConceptPropagationBindingPair >* nominalSchemaVarBindedNominalHash, CPROCESSINGHASH<CConcept*,CPropagationBindingDescriptor*>*& groundedConPropBindDesHash, CNominalSchemaTemplate* nsTemplate, CCalculationAlgorithmContext* calcAlgContext) {
255
256 CSortedNegLinker<CConcept*>* newGroundedConLinker = nullptr;
257
258
259 CReapplyConceptLabelSet* conLabelSet = indiProcessNode->getReapplyConceptLabelSet(false);
260
261 CBOXHASH<CConcept*,CConcept*>* templConNomSchConHash = nsTemplate->getTemplateConceptNominalSchemaConceptHash();
262 CBOXSET<CConcept*>* nomSchConSet = nsTemplate->getNominalSchemaConceptSet();
263
264 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator > nomSchConIndividualItHash;
265 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator indiItEnd = nominalSchemaVarBindedNominalHash->constEnd();
266 for (CBOXSET<CConcept*>::const_iterator it = nomSchConSet->constBegin(), itEnd = nomSchConSet->constEnd(); it != itEnd; ++it) {
267 CConcept* nomSchCon(*it);
268 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(nomSchCon);
269 nomSchConIndividualItHash.insert(nomSchCon,indiIt);
270 }
271
272
273
274 bool conVarItFinished = false;
275 while (!conVarItFinished) {
276
277
278 CConcept* templateConcept = nsTemplate->getTemplateConcept();
279 CSortedNegLinker<CConcept*>* opConLinker = createGroundedNominalSchemaConcept(templateConcept,negated,conLabelSet,templConNomSchConHash,&nomSchConIndividualItHash,calcAlgContext);
280 if (opConLinker) {
281 if (!groundedConPropBindDesHash) {
282 groundedConPropBindDesHash = CObjectParameterizingAllocator< CPROCESSINGHASH<CConcept*,CPropagationBindingDescriptor*>,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
283 }
284
285 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin(), variableItEnd = nomSchConIndividualItHash.constEnd();
286 while (variableIt != variableItEnd) {
287 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator nomBindIt = variableIt.value();
288 CPropagationBindingDescriptor* bindedDes = nomBindIt.value().second;
289 if (bindedDes) {
290 for (CSortedNegLinker<CConcept*>* opConLinkerIt = opConLinker; opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
291 CConcept* groundedConcept = opConLinkerIt->getData();
292 groundedConPropBindDesHash->insertMulti(groundedConcept,bindedDes);
293 }
294 }
295 ++variableIt;
296 }
297
298 newGroundedConLinker = opConLinker->append(newGroundedConLinker);
299 }
300
301
302
303
304
305 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin();
306 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >::const_iterator variableItEnd = nomSchConIndividualItHash.constEnd();
307
308
309 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator varIndiIt = variableIt.value();
310 CConcept* varConcept = variableIt.key();
311
312 ++varIndiIt;
313 bool conVarIteration = true;
314 while ((varIndiIt == indiItEnd || varIndiIt.key() != varConcept) && conVarIteration) {
315 conVarIteration = false;
316 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(varConcept);
317 nomSchConIndividualItHash.insert(varConcept,indiIt);
318
319 ++variableIt;
320 if (variableIt == variableItEnd) {
321 conVarItFinished = true;
322 } else {
323 varIndiIt = variableIt.value();
324 varConcept = variableIt.key();
325 ++varIndiIt;
326
327 if (varIndiIt == indiItEnd) {
328 conVarIteration = true;
329 }
330 }
331 }
332 if (!conVarItFinished) {
333 nomSchConIndividualItHash.insert(varConcept,varIndiIt);
334 }
335 }
336
337
338 return newGroundedConLinker;
339 }
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356 CSortedNegLinker<CConcept*>* CConceptNominalSchemaGroundingHandler::getGroundingConceptLinker(CIndividualProcessNode* processNode, CVariableBindingPathSet* varBindPathSet, CConcept* concept, bool negated, CPROCESSINGHASH<CConcept*,CVariableBindingPathDescriptor*>*& groundedConVarBindPathDesHash, CCalculationAlgorithmContext* calcAlgContext) {
357 CSortedNegLinker<CConcept*>* newLinker = nullptr;
358
359 mDataBox = calcAlgContext->getUsedProcessingDataBox();
360 CProcessContext* context = calcAlgContext->getUsedProcessContext();
361 mMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
362 CMBox* mBox = mDataBox->getOntology()->getDataBoxes()->getMBox();
363 mTBox = mDataBox->getOntology()->getDataBoxes()->getTBox();
364 mConceptVec = mDataBox->getExtendedConceptVector(false);
365 mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(false);
366 CNominalSchemaTemplateVector* nomSchVec = mBox->getNominalSchemaTemplateVector(false);
367 mLocalizedExtensions = false;
368
369
370 cint64 nomSchTemplID = concept->getParameter();
371
372
373 if (nomSchVec) {
374 CNominalSchemaTemplate* nomSchTempl = nomSchVec->getData(nomSchTemplID);
375 CConcept* templateConcept = nomSchTempl->getTemplateConcept();
376 CBOXHASH<CConcept*,CConcept*>* templateConceptNomSchVarHash = nomSchTempl->getTemplateConceptNominalSchemaConceptHash();
377 CBOXSET<CConcept*>* templateConceptNomSchVarSet = nomSchTempl->getNominalSchemaConceptSet();
378
379 CVariableBindingPathMap* varBindPathMap = varBindPathSet->getVariableBindingPathMap();
380 for (CVariableBindingPathMap::iterator it = varBindPathMap->begin(), itEnd = varBindPathMap->end(); it != itEnd; ++it) {
381 CVariableBindingPathMapData& varBindPathData = it.value();
382 CVariableBindingPathDescriptor* varBindPathDes = varBindPathData.getVariableBindingPathDescriptor();
383 CVariableBindingPath* varBindPath = varBindPathDes->getVariableBindingPath();
384
385 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair> nominalSchemaVarBindedNominalHash(calcAlgContext->getUsedTaskProcessorContext());
386 CPROCESSINGSET<CConcept*>* allNominalConceptSet = nullptr;
387
388 for (CVariableBindingDescriptor* varBindDesIt = varBindPath->getVariableBindingDescriptorLinker(); varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
389 CVariableBinding* varBind = varBindDesIt->getVariableBinding();
390 CVariable* variable = varBind->getBindedVariable();
391 CIndividualProcessNode* bindedIndiNode = varBind->getBindedIndividual();
392 if (variable->isNominalVariable()) {
393 CConcept* nomSchVarConcept = variable->getNominalVariableConcept();
394 if (templateConceptNomSchVarSet->contains(nomSchVarConcept)) {
395 CConcept* nominalConcept = getNominalConcept(bindedIndiNode,false,calcAlgContext);
396 if (nominalConcept) {
397 nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
398 }
399 }
400 }
401 }
402
403 for (CBOXSET<CConcept*>::iterator it = templateConceptNomSchVarSet->begin(), itEnd = templateConceptNomSchVarSet->end(); it != itEnd; ++it) {
404 CConcept* nomSchVarConcept = *it;
405 if (!nominalSchemaVarBindedNominalHash.contains(nomSchVarConcept)) {
406 collectAllNominalConcepts(allNominalConceptSet,calcAlgContext);
407 for (CPROCESSINGSET<CConcept*>::const_iterator nomIt = allNominalConceptSet->constBegin(), nomItEnd = allNominalConceptSet->constEnd(); nomIt != nomItEnd; ++nomIt) {
408 CConcept* nominalConcept(*nomIt);
409 nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
410 }
411 }
412 }
413
414 CSortedNegLinker<CConcept*>* tmpNewLinker = createNominalSchemaGroundingConcepts(processNode,nomSchTempl->getTemplateConcept(),negated,&nominalSchemaVarBindedNominalHash,nomSchTempl,calcAlgContext);
415 if (tmpNewLinker) {
416 for (CSortedNegLinker<CConcept*>* tmpNewLinkerIt = tmpNewLinker; tmpNewLinkerIt; tmpNewLinkerIt = tmpNewLinkerIt->getNext()) {
417 CConcept* concept = tmpNewLinkerIt->getData();
418 if (!groundedConVarBindPathDesHash) {
419 groundedConVarBindPathDesHash = CObjectParameterizingAllocator< CPROCESSINGHASH<CConcept*,CVariableBindingPathDescriptor*>,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
420 }
421 groundedConVarBindPathDesHash->insert(concept,varBindPathDes);
422 }
423 newLinker = tmpNewLinker->append(newLinker);
424 }
425
426 }
427 }
428
429 return newLinker;
430 }
431
432
433
434
435
436
437
438 CSortedNegLinker<CConcept*>* CConceptNominalSchemaGroundingHandler::getGroundingConceptLinker(CIndividualProcessNode* processNode, CRepresentativeVariableBindingPathMap* repVarBindPathSetMap, CConcept* concept, bool negated, CPROCESSINGHASH<CConcept*,CVariableBindingPath*>*& groundedConVarBindPathHash, CCalculationAlgorithmContext* calcAlgContext) {
439 CSortedNegLinker<CConcept*>* newLinker = nullptr;
440
441 mDataBox = calcAlgContext->getUsedProcessingDataBox();
442 CProcessContext* context = calcAlgContext->getUsedProcessContext();
443 mMemMan = calcAlgContext->getUsedProcessTaskMemoryAllocationManager();
444 CMBox* mBox = mDataBox->getOntology()->getDataBoxes()->getMBox();
445 CTBox* tBox = mDataBox->getOntology()->getDataBoxes()->getTBox();
446 mConceptVec = mDataBox->getExtendedConceptVector(false);
447 mReplaceHash = mDataBox->getConceptNominalSchemaGroundingHash(false);
448 CNominalSchemaTemplateVector* nomSchVec = mBox->getNominalSchemaTemplateVector(false);
449 mLocalizedExtensions = false;
450
451
452 cint64 nomSchTemplID = concept->getParameter();
453
454
455 if (nomSchVec) {
456 CNominalSchemaTemplate* nomSchTempl = nomSchVec->getData(nomSchTemplID);
457 CConcept* templateConcept = nomSchTempl->getTemplateConcept();
458 CBOXHASH<CConcept*,CConcept*>* templateConceptNomSchVarHash = nomSchTempl->getTemplateConceptNominalSchemaConceptHash();
459 CBOXSET<CConcept*>* templateConceptNomSchVarSet = nomSchTempl->getNominalSchemaConceptSet();
460
461 for (CRepresentativeVariableBindingPathMap::const_iterator it = repVarBindPathSetMap->constBegin(), itEnd = repVarBindPathSetMap->constEnd(); it != itEnd; ++it) {
462 const CRepresentativeVariableBindingPathMapData& varBindPathData = it.value();
463 CVariableBindingPath* varBindPath = varBindPathData.getVariableBindingPath();
464
465 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair> nominalSchemaVarBindedNominalHash(calcAlgContext->getUsedTaskProcessorContext());
466 CPROCESSINGSET<CConcept*>* allNominalConceptSet = nullptr;
467
468 for (CVariableBindingDescriptor* varBindDesIt = varBindPath->getVariableBindingDescriptorLinker(); varBindDesIt; varBindDesIt = varBindDesIt->getNext()) {
469 CVariableBinding* varBind = varBindDesIt->getVariableBinding();
470 CVariable* variable = varBind->getBindedVariable();
471 CIndividualProcessNode* bindedIndiNode = varBind->getBindedIndividual();
472 if (variable->isNominalVariable()) {
473 CConcept* nomSchVarConcept = variable->getNominalVariableConcept();
474 if (templateConceptNomSchVarSet->contains(nomSchVarConcept)) {
475 CConcept* nominalConcept = getNominalConcept(bindedIndiNode,false,calcAlgContext);
476 if (nominalConcept) {
477 nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
478 }
479 }
480 }
481 }
482
483 for (CBOXSET<CConcept*>::iterator it = templateConceptNomSchVarSet->begin(), itEnd = templateConceptNomSchVarSet->end(); it != itEnd; ++it) {
484 CConcept* nomSchVarConcept = *it;
485 if (!nominalSchemaVarBindedNominalHash.contains(nomSchVarConcept)) {
486 collectAllNominalConcepts(allNominalConceptSet,calcAlgContext);
487 for (CPROCESSINGSET<CConcept*>::const_iterator nomIt = allNominalConceptSet->constBegin(), nomItEnd = allNominalConceptSet->constEnd(); nomIt != nomItEnd; ++nomIt) {
488 CConcept* nominalConcept(*nomIt);
489 nominalSchemaVarBindedNominalHash.insertMulti(nomSchVarConcept,TConceptPropagationBindingPair(nominalConcept,nullptr));
490 }
491 }
492 }
493
494 CSortedNegLinker<CConcept*>* tmpNewLinker = createNominalSchemaGroundingConcepts(processNode,nomSchTempl->getTemplateConcept(),negated,&nominalSchemaVarBindedNominalHash,nomSchTempl,calcAlgContext);
495 if (tmpNewLinker) {
496 for (CSortedNegLinker<CConcept*>* tmpNewLinkerIt = tmpNewLinker; tmpNewLinkerIt; tmpNewLinkerIt = tmpNewLinkerIt->getNext()) {
497 CConcept* concept = tmpNewLinkerIt->getData();
498 if (!groundedConVarBindPathHash) {
499 groundedConVarBindPathHash = CObjectParameterizingAllocator< CPROCESSINGHASH<CConcept*,CVariableBindingPath*>,CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
500 }
501 groundedConVarBindPathHash->insert(concept,varBindPath);
502 }
503 newLinker = tmpNewLinker->append(newLinker);
504 }
505
506 }
507 }
508
509 return newLinker;
510 }
511
512
513
514
515
516
517
518
519 CSortedNegLinker<CConcept*>* CConceptNominalSchemaGroundingHandler::createGroundedNominalSchemaConcept(CConcept* concept, bool negated, CReapplyConceptLabelSet* conLabelSet, CBOXHASH<CConcept*,CConcept*>* templConNomSchConHash, QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >* nomSchConIndividualItHash, CCalculationAlgorithmContext* calcAlgContext) {
520 CSortedNegLinker<CConcept*>* conLinker = nullptr;
521 cint64 opCode = concept->getOperatorCode();
522 if (!negated && (opCode == CCAND) || negated && (opCode == CCOR)) {
523 for (CSortedNegLinker<CConcept*>* opConLinkerIt = concept->getOperandList(); opConLinkerIt; opConLinkerIt = opConLinkerIt->getNext()) {
524 CConcept* opConcept = opConLinkerIt->getData();
525 bool opConNegation = opConLinkerIt->isNegated()^negated;
526 CSortedNegLinker<CConcept*>* tmpConLinker = createGroundedNominalSchemaConcept(opConcept,opConNegation,conLabelSet,templConNomSchConHash,nomSchConIndividualItHash,calcAlgContext);
527 if (tmpConLinker) {
528 conLinker = tmpConLinker->append(conLinker);
529 }
530 }
531 } else {
532 CConcept* groundedConcept = createGroundedNominalSchemaConcept(concept,templConNomSchConHash,nomSchConIndividualItHash,calcAlgContext);
533 bool alreadyContained = false;
534 if (conLabelSet) {
535 alreadyContained = conLabelSet->containsConcept(groundedConcept);
536 }
537 if (!alreadyContained) {
538 CSortedNegLinker<CConcept*>* opConLinker = CObjectAllocator< CSortedNegLinker<CConcept*> >::allocateAndConstruct(mMemMan);
539 opConLinker->init(groundedConcept,negated);
540 conLinker = opConLinker->append(conLinker);
541 }
542
543 }
544 return conLinker;
545 }
546
547
548 CSortedNegLinker<CConcept*>* CConceptNominalSchemaGroundingHandler::createNominalSchemaGroundingConcepts(CIndividualProcessNode* indiProcessNode, CConcept* concept, bool negated, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>* nominalSchemaVarBindedNominalHash, CNominalSchemaTemplate* nsTemplate, CCalculationAlgorithmContext* calcAlgContext) {
549
550 CSortedNegLinker<CConcept*>* newGroundedConLinker = nullptr;
551
552
553 CReapplyConceptLabelSet* conLabelSet = indiProcessNode->getReapplyConceptLabelSet(false);
554
555 CBOXHASH<CConcept*,CConcept*>* templConNomSchConHash = nsTemplate->getTemplateConceptNominalSchemaConceptHash();
556 CBOXSET<CConcept*>* nomSchConSet = nsTemplate->getNominalSchemaConceptSet();
557
558 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator > nomSchConIndividualItHash;
559 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator indiItEnd = nominalSchemaVarBindedNominalHash->constEnd();
560 for (CBOXSET<CConcept*>::const_iterator it = nomSchConSet->constBegin(), itEnd = nomSchConSet->constEnd(); it != itEnd; ++it) {
561 CConcept* nomSchCon(*it);
562 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(nomSchCon);
563 nomSchConIndividualItHash.insert(nomSchCon,indiIt);
564 }
565
566 bool conVarItFinished = false;
567 while (!conVarItFinished) {
568
569 CConcept* templateConcept = nsTemplate->getTemplateConcept();
570 CSortedNegLinker<CConcept*>* opConLinker = createGroundedNominalSchemaConcept(templateConcept,negated,conLabelSet,templConNomSchConHash,&nomSchConIndividualItHash,calcAlgContext);
571 if (opConLinker) {
572 newGroundedConLinker = opConLinker->append(newGroundedConLinker);
573 }
574
575
576
577 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >::const_iterator variableIt = nomSchConIndividualItHash.constBegin();
578 QHash<CConcept*, CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator >::const_iterator variableItEnd = nomSchConIndividualItHash.constEnd();
579
580 if (variableIt == variableItEnd) {
581 conVarItFinished = true;
582 } else {
583
584 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator varIndiIt = variableIt.value();
585 CConcept* varConcept = variableIt.key();
586
587 ++varIndiIt;
588 bool conVarIteration = true;
589 while ((varIndiIt == indiItEnd || varIndiIt.key() != varConcept) && conVarIteration) {
590 conVarIteration = false;
591 CPROCESSINGHASH<CConcept*,TConceptPropagationBindingPair>::const_iterator indiIt = nominalSchemaVarBindedNominalHash->constFind(varConcept);
592 nomSchConIndividualItHash.insert(varConcept,indiIt);
593
594 ++variableIt;
595 if (variableIt == variableItEnd) {
596 conVarItFinished = true;
597 } else {
598 varIndiIt = variableIt.value();
599 varConcept = variableIt.key();
600 ++varIndiIt;
601
602 if (varIndiIt == indiItEnd) {
603 conVarIteration = true;
604 }
605 }
606 }
607 if (!conVarItFinished) {
608 nomSchConIndividualItHash.insert(varConcept,varIndiIt);
609 }
610 }
611 }
612
613
614 return newGroundedConLinker;
615 }
616
617
618
619
620
621 }; // end namespace Algorithm
622
623 }; // end namespace Kernel
624
625 }; // end namespace Reasoner
626
627 }; // end namespace Konclude