Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CDatatypeIndividualProcessNodeHandler.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 "CDatatypeIndividualProcessNodeHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32
33 CDatatypeIndividualProcessNodeHandler::CDatatypeIndividualProcessNodeHandler() {
34 mConfBuildDependencies = true;
35
36 CDatatypeValueSpaceTypes* valueSpaceTypes = CDatatypeValueSpaceTypes::getValueSpaceTypes();
37
38 CDatatypeValueSpaceRealType* realValueSpaceType = valueSpaceTypes->getValueSpaceRealType();
39 mValueSpaceHandlerArray[realValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeRealValueSpaceHandler(realValueSpaceType);
40 CDatatypeValueSpaceUnknownType* unknownValueSpaceType = valueSpaceTypes->getValueSpaceUnkownType();
41 mValueSpaceHandlerArray[unknownValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeUnknownValueSpaceHandler(unknownValueSpaceType);
42 CDatatypeValueSpaceStringType* stringValueSpaceType = valueSpaceTypes->getValueSpaceStringType();
43 mValueSpaceHandlerArray[stringValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeStringValueSpaceHandler(stringValueSpaceType);
44 CDatatypeValueSpaceBooleanType* booleanValueSpaceType = valueSpaceTypes->getValueSpaceBooleanType();
45 mValueSpaceHandlerArray[booleanValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeBooleanValueSpaceHandler(booleanValueSpaceType);
46 CDatatypeValueSpaceDoubleType* doubleValueSpaceType = valueSpaceTypes->getValueSpaceDoubleType();
47 mValueSpaceHandlerArray[doubleValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeDoubleValueSpaceHandler(doubleValueSpaceType);
48 CDatatypeValueSpaceFloatType* floatValueSpaceType = valueSpaceTypes->getValueSpaceFloatType();
49 mValueSpaceHandlerArray[floatValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeFloatValueSpaceHandler(floatValueSpaceType);
50 CDatatypeValueSpaceIRIType* iriValueSpaceType = valueSpaceTypes->getValueSpaceIRIType();
51 mValueSpaceHandlerArray[iriValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeIRIValueSpaceHandler(iriValueSpaceType);
52 CDatatypeValueSpaceBinaryBase64DataType* binaryBase64DataValueSpaceType = valueSpaceTypes->getValueSpaceBinaryBase64DataType();
53 mValueSpaceHandlerArray[binaryBase64DataValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeBinaryBase64DataValueSpaceHandler(binaryBase64DataValueSpaceType);
54 CDatatypeValueSpaceBinaryHexDataType* binaryHexDataValueSpaceType = valueSpaceTypes->getValueSpaceBinaryHexDataType();
55 mValueSpaceHandlerArray[binaryHexDataValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeBinaryHexDataValueSpaceHandler(binaryHexDataValueSpaceType);
56 CDatatypeValueSpaceXMLType* xmlValueSpaceType = valueSpaceTypes->getValueSpaceXMLType();
57 mValueSpaceHandlerArray[xmlValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeXMLValueSpaceHandler(xmlValueSpaceType);
58 CDatatypeValueSpaceDateTimeType* dateTimeValueSpaceType = valueSpaceTypes->getValueSpaceDateTimeType();
59 mValueSpaceHandlerArray[dateTimeValueSpaceType->getValueSpaceTypeIndex()] = new CIndividualProcessNodeDateTimeValueSpaceHandler(dateTimeValueSpaceType);
60 }
61
62
63 CDatatypeIndividualProcessNodeHandler::~CDatatypeIndividualProcessNodeHandler() {
64 }
65
66
67
68
69
70 bool CDatatypeIndividualProcessNodeHandler::triggerDataLiteralConcept(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) {
71 bool triggerInstalled = false;
72 bool directlyTriggered = false;
73 CDatatype* datatype = dataLiteral->getDatatype();
74
75 if (datatype) {
76 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
77 if (valueSpaceType) {
78 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
79 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType, true);
80 if (!valueSpaceData->isValueSpaceClashed()) {
81 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType, calcAlgContext);
82 CConceptDescriptor* conceptTriggerLinker = nullptr;
83 CDatatypeDependencyCollection depCollection(calcAlgContext);
84 bool otherValueSpacesClosed = false;
85 if (areOtherValueSpacesClosed(indiProcNode,valueSpaceType,calcAlgContext)) {
86 otherValueSpacesClosed = true;
87 }
88 triggerInstalled |= valueSpaceHandler->triggerDataLiteralConcept(indiProcNode, dataLiteral, negated, depTrackPoint, triggerConcept, otherValueSpacesClosed, &directlyTriggered, &depCollection, calcAlgContext);
89 if (directlyTriggered) {
90 CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr;
91 addClosedValueSpacedDependencies(indiProcNode, &depCollection, calcAlgContext);
92 datatypeTriggerDepTrackPoint = depCollection.getDatatypeTriggerDependencyTrackPoint();
93 CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
94 newConceptLinker->initConceptDescriptor(triggerConcept, false, datatypeTriggerDepTrackPoint);
95 triggeredConcepts = newConceptLinker;
96 }
97 }
98 }
99 }
100 if (triggerInstalled) {
101 processValueSpaceModified(indiProcNode, calcAlgContext);
102 }
103 return triggerInstalled;
104 }
105
106
107
108 bool CDatatypeIndividualProcessNodeHandler::triggerDatatypeConcept(CIndividualProcessNode* indiProcNode, CDatatype* datatype, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) {
109 bool triggerInstalled = false;
110 bool directlyTriggered = false;
111 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
112 if (valueSpaceType) {
113 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
114 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType, true);
115 if (!valueSpaceData->isValueSpaceClashed()) {
116 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType, calcAlgContext);
117 CConceptDescriptor* conceptTriggerLinker = nullptr;
118 CDatatypeDependencyCollection depCollection(calcAlgContext);
119 bool otherValueSpacesClosed = false;
120 if (areOtherValueSpacesClosed(indiProcNode, valueSpaceType, calcAlgContext)) {
121 otherValueSpacesClosed = true;
122 }
123 triggerInstalled |= valueSpaceHandler->triggerDatatypeConcept(indiProcNode, datatype, negated, depTrackPoint, triggerConcept, otherValueSpacesClosed, &directlyTriggered, &depCollection, calcAlgContext);
124 if (directlyTriggered) {
125 CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr;
126 addClosedValueSpacedDependencies(indiProcNode, &depCollection, calcAlgContext);
127 datatypeTriggerDepTrackPoint = depCollection.getDatatypeTriggerDependencyTrackPoint();
128 CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
129 newConceptLinker->initConceptDescriptor(triggerConcept, false, datatypeTriggerDepTrackPoint);
130 triggeredConcepts = newConceptLinker;
131 }
132 }
133 }
134 if (triggerInstalled) {
135 processValueSpaceModified(indiProcNode, calcAlgContext);
136 }
137 return triggerInstalled;
138 }
139
140
141
142
143
144 bool CDatatypeIndividualProcessNodeHandler::triggerDataRestrictionConcept(CIndividualProcessNode* indiProcNode, CConcept* dataRestriction, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) {
145 bool triggerInstalled = false;
146 bool directlyTriggered = false;
147 CDatatypeValueSpaceType* valueSpaceType = dataRestriction->getDatatype()->getValueSpaceType();
148 if (valueSpaceType) {
149 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
150 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType, true);
151 if (!valueSpaceData->isValueSpaceClashed()) {
152 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType, calcAlgContext);
153 CConceptDescriptor* conceptTriggerLinker = nullptr;
154 CDatatypeDependencyCollection depCollection(calcAlgContext);
155 bool otherValueSpacesClosed = false;
156 if (areOtherValueSpacesClosed(indiProcNode, valueSpaceType, calcAlgContext)) {
157 otherValueSpacesClosed = true;
158 }
159 triggerInstalled |= valueSpaceHandler->triggerDataRestrictionConcept(indiProcNode, dataRestriction, negated, depTrackPoint, triggerConcept, otherValueSpacesClosed, &directlyTriggered, &depCollection, calcAlgContext);
160 if (directlyTriggered) {
161 CDependencyTrackPoint* datatypeTriggerDepTrackPoint = nullptr;
162 addClosedValueSpacedDependencies(indiProcNode, &depCollection, calcAlgContext);
163 datatypeTriggerDepTrackPoint = depCollection.getDatatypeTriggerDependencyTrackPoint();
164 CConceptDescriptor* newConceptLinker = CObjectAllocator< CConceptDescriptor >::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
165 newConceptLinker->initConceptDescriptor(triggerConcept, false, datatypeTriggerDepTrackPoint);
166 triggeredConcepts = newConceptLinker;
167 }
168 }
169 }
170 if (triggerInstalled) {
171 processValueSpaceModified(indiProcNode, calcAlgContext);
172 }
173 return triggerInstalled;
174 }
175
176
177
178 bool CDatatypeIndividualProcessNodeHandler::areOtherValueSpacesClosed(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceType* openValueSpaceType, CCalculationAlgorithmContext* calcAlgContext) {
179 bool allOtherClosed = true;
180 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
181 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
182 for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
183 if (valueSpaceTypeIt != openValueSpaceType) {
184 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt, false);
185 if (!valueSpaceData || !valueSpaceData->isValueSpaceClashed()) {
186 allOtherClosed = false;
187 }
188 }
189 }
190 return allOtherClosed;
191 }
192
193
194
195 CDatatypeDependencyCollection* CDatatypeIndividualProcessNodeHandler::addClosedValueSpacedDependencies(CIndividualProcessNode* indiProcNode, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
196 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
197 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
198 for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
199 if (valueSpaceTypeIt) {
200 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt, false);
201 if (valueSpaceData && valueSpaceData->isValueSpaceClashed()) {
202 addValueSpaceDependencies(indiProcNode, valueSpaceData, valueSpaceTypeIt, depCollection, calcAlgContext);
203 }
204 }
205 }
206 return depCollection;
207 }
208
209
210 bool CDatatypeIndividualProcessNodeHandler::addDatatype(CIndividualProcessNode* indiProcNode, CConcept* datatypeConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
211 bool potentiallyModified = false;
212 CDatatype* datatype = datatypeConcept->getDatatype();
213
214 if (datatype) {
215 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
216 if (valueSpaceType) {
217 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
218 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType,true);
219 valueSpaceData->setValueSpaceInitialisationDependencyTrackPointCandidate(depTrackPoint);
220
221 if (!negated) {
222 potentiallyModified |= closeOtherValueSpaces(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext);
223 } else {
224 potentiallyModified |= closeValueSpace(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext);
225 }
226 }
227 }
228
229
230 if (potentiallyModified) {
231 processValueSpaceModified(indiProcNode,calcAlgContext);
232 }
233 return potentiallyModified;
234 }
235
236
237
238 bool CDatatypeIndividualProcessNodeHandler::addDataLiteral(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
239 bool potentiallyModified = false;
240 CDatatype* datatype = dataLiteral->getDatatype();
241
242 if (datatype) {
243 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
244 if (valueSpaceType) {
245 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext);
246 potentiallyModified |= valueSpaceHandler->addDataLiteral(indiProcNode,dataLiteral,negated,depTrackPoint,calcAlgContext);
247 if (!negated) {
248 potentiallyModified |= closeOtherValueSpaces(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext);
249 }
250 }
251 }
252 if (potentiallyModified) {
253 processValueSpaceModified(indiProcNode,calcAlgContext);
254 }
255 return potentiallyModified;
256 }
257
258
259
260
261 bool CDatatypeIndividualProcessNodeHandler::addDataRestriction(CIndividualProcessNode* indiProcNode, CConcept* dataRestricionConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
262 bool potentiallyModified = false;
263 CDatatype* datatype = dataRestricionConcept->getDatatype();
264
265 cint64 restrictionCode = dataRestricionConcept->getParameter();
266 CDataLiteral* dataLiteral = dataRestricionConcept->getDataLiteral();
267 if (datatype) {
268 CDatatypeValueSpaceType* valueSpaceType = datatype->getValueSpaceType();
269 if (valueSpaceType) {
270 if (dataLiteral && dataLiteral->getDatatype()) {
271 if (valueSpaceType != dataLiteral->getDatatype()->getValueSpaceType()) {
272 return false;
273 }
274 }
275 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext);
276 potentiallyModified |= valueSpaceHandler->addDataRestriction(indiProcNode,dataRestricionConcept,negated,depTrackPoint,calcAlgContext);
277 if (!negated && restrictionCode > 0) {
278 potentiallyModified |= closeOtherValueSpaces(indiProcNode,valueSpaceType,depTrackPoint,calcAlgContext);
279 }
280 }
281 }
282 if (potentiallyModified) {
283 processValueSpaceModified(indiProcNode,calcAlgContext);
284 }
285 return potentiallyModified;
286 }
287
288
289 bool CDatatypeIndividualProcessNodeHandler::processValueSpaceModified(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
290 // test clashes
291 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false);
292 if (datatypesSpaceValue->isValueSpaceClashCheckingRequired()) {
293 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
294 datatypesSpaceValue->setValueSpaceClashCheckingRequired(false);
295 testAllValueSpacesClashed(indiProcNode,calcAlgContext);
296 }
297 // queue triggering
298 if (datatypesSpaceValue->isValueSpaceTriggeringRequired()) {
299 if (!datatypesSpaceValue->isValueSpaceTriggeringQueued()) {
300 CDatatypeValueSpacesTriggers* valueSpacesTriggers = calcAlgContext->getUsedProcessingDataBox()->getOntology()->getDataBoxes()->getMBox()->getValueSpacesTriggers(false);
301 if (valueSpacesTriggers) {
302 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
303 calcAlgContext->getUsedProcessingDataBox()->getValueSpaceTriggeringProcessingQueue(true)->insertProcessIndiviudal(indiProcNode);
304 datatypesSpaceValue->setValueSpaceTriggeringQueued(true);
305 }
306 }
307 }
308 // queue satisfiability checking
309 if (datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingRequired()) {
310 if (!datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingQueued()) {
311 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
312 CDatatypeValueSpaceValuesCounter valuesCounter;
313 countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext);
314 cint64 disjointCount = getDisjointCount(indiProcNode,calcAlgContext);
315 if (!valuesCounter.hasValueAchieved(disjointCount+1)) {
316 // requires detailed satisfiability checking
317 calcAlgContext->getUsedProcessingDataBox()->getDistinctValueSpaceSatisfiabilityCheckingQueue(true)->insertProcessIndiviudal(indiProcNode);
318 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingQueued(true);
319 } else {
320 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false);
321 }
322 }
323 }
324 return true;
325 }
326
327
328
329
330
331
332 bool CDatatypeIndividualProcessNodeHandler::triggerValueSpaceConcepts(CIndividualProcessNode* indiProcNode, CConceptDescriptor*& triggeredConcepts, CCalculationAlgorithmContext* calcAlgContext) {
333 cint64 distinctCount = getDisjointCount(indiProcNode,calcAlgContext);
334 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
335 CConceptDescriptor* conceptTriggerLinker = nullptr;
336 bool triggered = false;
337
338 if (datatypesSpaceValue->isValueSpaceTriggeringRequired() || distinctCount > datatypesSpaceValue->getLastTriggeringDisjointCount()) {
339 datatypesSpaceValue->setLastTriggeringDisjointCount(distinctCount);
340
341 cint64 remainingRequiredValueCount = distinctCount+1;
342
343 CDatatypeDependencyCollection depCollection(calcAlgContext);
344 addDistinctDependencies(indiProcNode,&depCollection,calcAlgContext);
345
346 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
347 CDatatypeValueSpaceType* valueSpaceTypeLinker = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker();
348 for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypeLinker; remainingRequiredValueCount > 0 && valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
349 CDatatypeValueSpaceType* valueSpaceType = valueSpaceTypeIt;
350 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceType,false);
351 if (valueSpaceData && valueSpaceData->isValueSpaceClashed()) {
352 addValueSpaceDependencies(indiProcNode,valueSpaceData,valueSpaceType,&depCollection,calcAlgContext);
353 } else {
354 conceptTriggerLinker = triggerValueSpaceConcepts(indiProcNode,conceptTriggerLinker,remainingRequiredValueCount,valueSpaceData,valueSpaceType,&depCollection,calcAlgContext);
355 }
356 }
357
358 datatypesSpaceValue->setValueSpaceTriggeringRequired(false);
359 triggered = true;
360 }
361 datatypesSpaceValue->setValueSpaceTriggeringQueued(false);
362
363 triggeredConcepts = conceptTriggerLinker;
364 return triggered;
365 }
366
367
368
369
370 bool CDatatypeIndividualProcessNodeHandler::notifyDistinctChanges(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
371 bool queued = false;
372 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false);
373 if (datatypesSpaceValue) {
374
375 if (!datatypesSpaceValue->isValueSpaceTriggeringQueued()) {
376 cint64 disjointCount = getDisjointCount(indiProcNode,calcAlgContext);
377 if (datatypesSpaceValue->isValueSpaceTriggeringRequired() || datatypesSpaceValue->getLastTriggeringDisjointCount() < disjointCount) {
378 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
379 calcAlgContext->getUsedProcessingDataBox()->getValueSpaceTriggeringProcessingQueue(true)->insertProcessIndiviudal(indiProcNode);
380 datatypesSpaceValue->setValueSpaceTriggeringQueued(true);
381 datatypesSpaceValue->setValueSpaceTriggeringRequired(true);
382 queued = true;
383 }
384 }
385
386 if (!datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingQueued()) {
387 CDatatypeValueSpaceValuesCounter valuesCounter;
388 countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext);
389 cint64 disjointCount = getDisjointCount(indiProcNode,calcAlgContext);
390 if (datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingRequired() || !valuesCounter.hasValueAchieved(disjointCount+1)) {
391 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
392 calcAlgContext->getUsedProcessingDataBox()->getDistinctValueSpaceSatisfiabilityCheckingQueue(true)->insertProcessIndiviudal(indiProcNode);
393 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingQueued(true);
394 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(true);
395 queued = true;
396 }
397 }
398
399 }
400 return queued;
401 }
402
403
404
405
406 bool CDatatypeIndividualProcessNodeHandler::involveDistinctNodeForSatisfiabilityChecking(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
407 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false);
408 if (datatypesSpaceValue) {
409 cint64 requiredValueCount = getDisjointCount(indiProcNode,calcAlgContext)+1;
410 CDatatypeValueSpaceValuesCounter valuesCounter;
411 countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext);
412 if (!valuesCounter.hasValueAchieved(requiredValueCount)) {
413 return true;
414 }
415 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
416 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false);
417 }
418 return false;
419 }
420
421
422 bool CDatatypeIndividualProcessNodeHandler::requiresSatisfiabilityChecking(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
423 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false);
424 if (datatypesSpaceValue) {
425 if (datatypesSpaceValue->isValueSpaceSatisfiabilityCheckingRequired()) {
426
427 cint64 requiredValueCount = getDisjointCount(indiProcNode,calcAlgContext)+1;
428 CDatatypeValueSpaceValuesCounter valuesCounter;
429 countPossibleValues(indiProcNode,&valuesCounter,calcAlgContext);
430 if (!valuesCounter.hasValueAchieved(requiredValueCount)) {
431 return true;
432 }
433 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
434 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false);
435 }
436 }
437 return false;
438 }
439
440
441
442
443
444 bool CDatatypeIndividualProcessNodeHandler::checkSatisfiability(CIndividualProcessNode* indiProcNode, CPROCESSINGSET<CIndividualProcessNode*>* distinctIndividualNodeSet, CCalculationAlgorithmContext* calcAlgContext) {
445
446
447 indiProcNode->getDatatypesValueSpaceData(true)->setValueSpaceSatisfiabilityCheckingQueued(false);
448
449 if (distinctIndividualNodeSet->size() > 1) {
450
451 CTaskProcessorContext* taskProcessorContext = calcAlgContext->getUsedTaskProcessorContext();
452 CIndividualProcessNodeVector* indiNodeVector = calcAlgContext->getProcessingDataBox()->getIndividualProcessNodeVector();
453 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
454 CDatatypeValueSpaceTypes* valueSpaceTypes = ontology->getDataBoxes()->getDatatypeValueSpaceTypes();
455 CDatatypeValueSpaceType* valueSpaceLinker = valueSpaceTypes->getValueSpaceTypeLinker();
456
457
458 CPROCESSINGMAP<cint64,CIndividualProcessNode*>* sortedDistinctNodeMap = CObjectParameterizingAllocator< CPROCESSINGMAP<cint64,CIndividualProcessNode*>,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext);
459 for (CPROCESSINGSET<CIndividualProcessNode*>::const_iterator it = distinctIndividualNodeSet->constBegin(), itEnd = distinctIndividualNodeSet->constEnd(); it != itEnd; ++it) {
460 CIndividualProcessNode* distinctIndiNode(*it);
461 cint64 distinctIndiID = distinctIndiNode->getIndividualNodeID();
462 sortedDistinctNodeMap->insert(distinctIndiID,distinctIndiNode);
463 }
464
465
466 CDatatypeValueTestingCollection valueTestingCollection(calcAlgContext);
467 CPROCESSINGHASH<cint64,CDataLiteralValue*>* nodeValueAssociationHash = CObjectParameterizingAllocator< CPROCESSINGHASH<cint64,CDataLiteralValue*>,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext);
468 CPROCESSINGHASH<cint64,CDatatypeValueSpaceType*>* nodeValueTypeAssociationHash = CObjectParameterizingAllocator< CPROCESSINGHASH<cint64,CDatatypeValueSpaceType*>,CContext* >::allocateAndConstructAndParameterize(taskProcessorContext->getMemoryAllocationManager(),taskProcessorContext);
469
470
471
472 CPROCESSINGMAP<cint64,CIndividualProcessNode*>::iterator firstValueit = sortedDistinctNodeMap->begin();
473 cint64 firstIndiNodeID = firstValueit.key();
474 CIndividualProcessNode* firstIndiNode = firstValueit.value();
475 sortedDistinctNodeMap->erase(firstValueit);
476 CDatatypeValueSpaceType* firstIndiNodeValueSpaceType = valueSpaceLinker;
477 CDataLiteralValue* firstIndiNextValue = nullptr;
478 CDataLiteralValue* firstIndiLastValue = nullptr;
479
480
481 bool foundSatisfiableValues = false;
482 bool moreValuesPossible = true;
483 while (moreValuesPossible && !foundSatisfiableValues) {
484 valueTestingCollection.releaseUsedDataLiteralValues();
485 CDatatypeValueSpaceType* firstIndiNodeLastValueSpaceType = firstIndiNodeValueSpaceType;
486 bool firstNodeFoundValue = seachNextPossibleDataValue(firstIndiNode,firstIndiNextValue,firstIndiNodeValueSpaceType,firstIndiLastValue,&valueTestingCollection,calcAlgContext);
487 if (firstNodeFoundValue) {
488 if (firstIndiLastValue) {
489 valueTestingCollection.releaseDataLiteralValue(firstIndiLastValue,firstIndiNodeLastValueSpaceType);
490 }
491 firstIndiLastValue = firstIndiNextValue;
492
493 for (CPROCESSINGMAP<cint64,CIndividualProcessNode*>::const_iterator it = sortedDistinctNodeMap->constBegin(), itEnd = sortedDistinctNodeMap->constEnd(); it != itEnd; ++it) {
494 cint64 indiNodeID = it.key();
495 CIndividualProcessNode* indiNode = it.value();
496 nodeValueAssociationHash->insert(indiNodeID,nullptr);
497 nodeValueTypeAssociationHash->insert(indiNodeID,valueSpaceLinker);
498 }
499
500
501 nodeValueAssociationHash->insert(firstIndiNodeID,firstIndiLastValue);
502 nodeValueTypeAssociationHash->insert(firstIndiNodeID,firstIndiNodeValueSpaceType);
503
504
505
506 bool allNodesFoundValue = true;
507
508 for (CPROCESSINGMAP<cint64,CIndividualProcessNode*>::const_iterator it = sortedDistinctNodeMap->constBegin(), itEnd = sortedDistinctNodeMap->constEnd(); allNodesFoundValue && it != itEnd; ++it) {
509 valueTestingCollection.releaseUsedDataLiteralValues();
510 cint64 indiNodeID = it.key();
511 CIndividualProcessNode* indiNode = it.value();
512 CDataLiteralValue* nodeLastTestingValue = nodeValueAssociationHash->value(indiNodeID);
513 CDatatypeValueSpaceType* nodeValueSpaceType = nodeValueTypeAssociationHash->value(indiNodeID);
514 CDataLiteralValue* nodeNextTestingValue = nullptr;
515
516
517 CDistinctHash* distinctHash = indiNode->getDistinctHash(false);
518 if (distinctHash) {
519 CDistinctIterator distinctIterator = distinctHash->getDistinctIterator();
520 while (distinctIterator.hasNext()) {
521 cint64 distinctIndiID = distinctIterator.nextDistinctIndividualID();
522 if (distinctIndiID < indiNodeID && sortedDistinctNodeMap->contains(distinctIndiID)) {
523 CDataLiteralValue* distinctValue = nodeValueAssociationHash->value(distinctIndiID);
524 CDatatypeValueSpaceType* distinctValueSpaceType = nodeValueTypeAssociationHash->value(distinctIndiID);
525 valueTestingCollection.addDataLiteralValueUse(distinctValue,distinctValueSpaceType);
526 }
527 }
528 }
529
530
531 CDatatypeValueSpaceType* nodeLastValueSpaceType = nodeValueSpaceType;
532 bool foundValue = seachNextPossibleDataValue(indiNode,nodeNextTestingValue,nodeValueSpaceType,nodeLastTestingValue,&valueTestingCollection,calcAlgContext);
533 if (!foundValue) {
534 allNodesFoundValue = false;
535 } else {
536 if (nodeLastTestingValue) {
537 valueTestingCollection.releaseDataLiteralValue(nodeLastTestingValue,nodeLastValueSpaceType);
538 }
539 nodeValueAssociationHash->insert(indiNodeID,nodeNextTestingValue);
540 nodeValueTypeAssociationHash->insert(indiNodeID,nodeValueSpaceType);
541 }
542 }
543
544
545 if (allNodesFoundValue) {
546 foundSatisfiableValues = true;
547 }
548
549
550 } else {
551 moreValuesPossible = false;
552 }
553 }
554
555
556 if (foundSatisfiableValues) {
557 // mark for all nodes that value space satisfiability is checked
558
559 for (CPROCESSINGSET<CIndividualProcessNode*>::const_iterator it = distinctIndividualNodeSet->constBegin(), itEnd = distinctIndividualNodeSet->constEnd(); it != itEnd; ++it) {
560 CIndividualProcessNode* distinctIndiNode(*it);
561 CDatatypesValueSpaceData* datatypesSpaceValue = distinctIndiNode->getDatatypesValueSpaceData(true);
562 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false);
563 }
564
565 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
566 datatypesSpaceValue->setValueSpaceSatisfiabilityCheckingRequired(false);
567 } else {
568 // create clash
569 CDatatypeDependencyTrackPointCollection clashedDepTrackPointCollection(calcAlgContext->getUsedProcessContext());
570 for (CPROCESSINGSET<CIndividualProcessNode*>::const_iterator it = distinctIndividualNodeSet->constBegin(), itEnd = distinctIndividualNodeSet->constEnd(); it != itEnd; ++it) {
571 CIndividualProcessNode* distinctIndiNode(*it);
572 addValueSpacesDependencies(distinctIndiNode,&clashedDepTrackPointCollection,calcAlgContext);
573 addDistinctDependencies(distinctIndiNode,&clashedDepTrackPointCollection,calcAlgContext);
574 }
575
576 CClashedDependencyDescriptor* depDesLinker = nullptr;
577 depDesLinker = copyClashedDependencyDescriptors(depDesLinker,clashedDepTrackPointCollection.getClashedDependencyDescriptors(),calcAlgContext);
578 throwDatatypeValueSpaceExclusionClash(depDesLinker,indiProcNode,calcAlgContext);
579
580 }
581 }
582
583
584
585 return true;
586 }
587
588
589 bool CDatatypeIndividualProcessNodeHandler::addDistinctDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
590
591 bool dependenciesAdded = false;
592 cint64 indiNodeID = indiProcNode->getIndividualNodeID();
593 CDistinctHash* distinctHash = indiProcNode->getDistinctHash(false);
594 if (distinctHash) {
595 CDistinctIterator distinctIterator = distinctHash->getDistinctIterator();
596 while (distinctIterator.hasNext()) {
597 CDistinctEdge* distinctEdge = distinctIterator.next();
598 CDependencyTrackPoint* depTrackPoint = distinctEdge->getDependencyTrackPoint();
599 dependenciesAdded |= depCollection->addDependency(depTrackPoint);
600 }
601 }
602 return dependenciesAdded;
603 }
604
605
606
607 bool CDatatypeIndividualProcessNodeHandler::seachNextPossibleDataValue(CIndividualProcessNode* indiProcNode, CDataLiteralValue*& nextValue, CDatatypeValueSpaceType*& nextValueSpaceType, CDataLiteralValue* lastValue, CDatatypeValueTestingCollection* valueTestingCollection, CCalculationAlgorithmContext* calcAlgContext) {
608
609 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
610
611 for (; nextValueSpaceType; nextValueSpaceType = nextValueSpaceType->getNextValueSpaceType()) {
612 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(nextValueSpaceType,false);
613 if (!valueSpaceData->isValueSpaceClashed()) {
614 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(nextValueSpaceType,calcAlgContext);
615 if (valueSpaceHandler->getNextPossibleDataValue(indiProcNode,nextValue,lastValue,valueTestingCollection,calcAlgContext)) {
616 return true;
617 }
618 }
619 }
620
621 return false;
622 }
623
624
625
626 bool CDatatypeIndividualProcessNodeHandler::countPossibleValues(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceValuesCounter* valuesCounter, CCalculationAlgorithmContext* calcAlgContext) {
627
628 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(false);
629
630 if (!datatypesSpaceValue->isValueSpaceCounted() || datatypesSpaceValue->isValueSpaceCountingRequired()) {
631 datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
632 datatypesSpaceValue->setValueSpaceCounted(true);
633 datatypesSpaceValue->setValueSpaceCountingRequired(false);
634
635 CDatatypeValueSpaceValuesCounter* valueSpacesValuesCounter = datatypesSpaceValue->getValuesCounter();
636 valueSpacesValuesCounter->resetValueCounter();
637
638 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
639 CDatatypeValueSpaceType* valueSpaceTypeLinker = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker();
640 for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypeLinker; valueSpaceTypeIt && !valueSpacesValuesCounter->isInfinite(); valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
641 CDatatypeValueSpaceType* valueSpaceType = valueSpaceTypeIt;
642 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext);
643 valueSpaceHandler->countPossibleValueSpaceValues(indiProcNode,valueSpacesValuesCounter,calcAlgContext);
644 }
645 }
646
647 bool counted = false;
648 if (valuesCounter) {
649 CDatatypeValueSpaceValuesCounter* valueSpacesValuesCounter = datatypesSpaceValue->getValuesCounter();
650 counted = valuesCounter->combineWithValueCounter(valueSpacesValuesCounter);
651 }
652 return counted;
653 }
654
655
656
657
658 bool CDatatypeIndividualProcessNodeHandler::addValueSpacesDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
659 bool dependenciesAdded = false;
660 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
661 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
662 for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
663 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt,false);
664 if (valueSpaceData) {
665 dependenciesAdded = addValueSpaceDependencies(indiProcNode,valueSpaceData,valueSpaceTypeIt,depCollection,calcAlgContext);
666 }
667 }
668 return dependenciesAdded;
669 }
670
671
672
673 bool CDatatypeIndividualProcessNodeHandler::addValueSpaceDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceData* valueSpaceData, CDatatypeValueSpaceType* valueSpaceType, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
674 if (valueSpaceData->isValueSpaceClashed()) {
675 bool depAddeds = false;
676 CClashedDependencyDescriptor* clashedDepDesLinker = valueSpaceData->getClashDependencyDescriptorLinker();
677 for (CClashedDependencyDescriptor* clashedDepDesIt = clashedDepDesLinker; clashedDepDesIt; clashedDepDesIt = clashedDepDesIt->getNext()) {
678 CDependencyTrackPoint* depTrackPoint = clashedDepDesIt->getDependencyTrackPoint();
679 depAddeds |= depCollection->addDependency(depTrackPoint);
680 }
681 return depAddeds;
682 } else {
683 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext);
684 return valueSpaceHandler->addValueSpaceDependencies(indiProcNode,depCollection,calcAlgContext);
685 }
686 return false;
687 }
688
689
690
691
692 CIndividualProcessNodeValueSpaceHandler* CDatatypeIndividualProcessNodeHandler::getValueSpaceHandler(CDatatypeValueSpaceType* valueSpaceType, CCalculationAlgorithmContext* calcAlgContext) {
693 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = nullptr;
694 valueSpaceHandler = mValueSpaceHandlerArray[valueSpaceType->getValueSpaceTypeIndex()];
695 return valueSpaceHandler;
696 }
697
698
699
700 cint64 CDatatypeIndividualProcessNodeHandler::getDisjointCount(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
701 cint64 disjointCount = 0;
702 CDistinctHash* distinctHash = indiProcNode->getDistinctHash(false);
703 if (distinctHash) {
704 disjointCount = distinctHash->getDistinctCount();
705 }
706 return disjointCount;
707 }
708
709
710
711 bool CDatatypeIndividualProcessNodeHandler::closeValueSpace(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceType* closeValueSpaceType, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
712 bool valueSpaceClosed = false;
713 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(closeValueSpaceType,calcAlgContext);
714 if (valueSpaceHandler) {
715 valueSpaceClosed |= valueSpaceHandler->closeValueSpace(indiProcNode,depTrackPoint,calcAlgContext);
716 }
717 return valueSpaceClosed;
718 }
719
720
721
722
723 bool CDatatypeIndividualProcessNodeHandler::closeOtherValueSpaces(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceType* exceptionValueSpaceType, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
724 bool valueSpaceClosed = false;
725 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
726 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
727 for (CDatatypeValueSpaceType* valueSpaceTypeIt = ontology->getDataBoxes()->getDatatypeValueSpaceTypes()->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
728 if (valueSpaceTypeIt != exceptionValueSpaceType) {
729 valueSpaceClosed |= closeValueSpace(indiProcNode,valueSpaceTypeIt,depTrackPoint,calcAlgContext);
730 }
731 }
732 return valueSpaceClosed;
733 }
734
735
736
737
738
739
740
741 bool CDatatypeIndividualProcessNodeHandler::testAllValueSpacesClashed(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
742 bool allClashed = true;
743
744 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
745 CDatatypeValueSpaceTypes* valueSpaceTypes = ontology->getDataBoxes()->getDatatypeValueSpaceTypes();
746
747 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
748
749 for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypes->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
750 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceTypeIt,calcAlgContext);
751 allClashed &= valueSpaceHandler->testValueSpaceClashed(indiProcNode,calcAlgContext);
752 }
753
754 if (allClashed) {
755
756 CClashedDependencyDescriptor* depDesLinker = nullptr;
757 for (CDatatypeValueSpaceType* valueSpaceTypeIt = valueSpaceTypes->getValueSpaceTypeLinker(); valueSpaceTypeIt; valueSpaceTypeIt = valueSpaceTypeIt->getNextValueSpaceType()) {
758 CDatatypeValueSpaceData* valueSpaceData = datatypesSpaceValue->getValueSpace(valueSpaceTypeIt,false);
759 if (valueSpaceData) {
760 depDesLinker = copyClashedDependencyDescriptors(depDesLinker,valueSpaceData->getClashDependencyDescriptorLinker(),calcAlgContext);
761 }
762 }
763 throwDatatypeValueSpaceExclusionClash(depDesLinker,indiProcNode,calcAlgContext);
764 }
765 return allClashed;
766 }
767
768
769
770
771 void CDatatypeIndividualProcessNodeHandler::throwDatatypeValueSpaceExclusionClash(CClashedDependencyDescriptor* depDesLinker, CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
772 CClashedDatatypeValueSpaceExclusionDescriptor* clashDepLinker = nullptr;
773 for (CClashedDependencyDescriptor* copyDepDesLinkerIt = depDesLinker; copyDepDesLinkerIt; copyDepDesLinkerIt = copyDepDesLinkerIt->getNext()) {
774 CClashedDatatypeValueSpaceExclusionDescriptor* clashDes = CObjectAllocator<CClashedDatatypeValueSpaceExclusionDescriptor>::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
775 clashDes->initClashedDatatypeValueSpaceExclusionDescriptor(copyDepDesLinkerIt->getDependencyTrackPoint(),indiProcNode);
776 clashDepLinker = (CClashedDatatypeValueSpaceExclusionDescriptor*)clashDes->append(clashDepLinker);
777 }
778 throw CCalculationClashProcessingException(clashDepLinker);
779 }
780
781
782 CClashedDependencyDescriptor* CDatatypeIndividualProcessNodeHandler::createClashedDependencyDescriptor(CClashedDependencyDescriptor* appendDepDesLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
783 if (depTrackPoint) {
784 CClashedDependencyDescriptor* clashDes = CObjectAllocator<CClashedDependencyDescriptor>::allocateAndConstruct(calcAlgContext->getUsedProcessTaskMemoryAllocationManager());
785 clashDes->initClashedDependencyDescriptor(depTrackPoint);
786 clashDes->append(appendDepDesLinker);
787 return clashDes;
788 } else {
789 return appendDepDesLinker;
790 }
791 }
792
793 CClashedDependencyDescriptor* CDatatypeIndividualProcessNodeHandler::copyClashedDependencyDescriptors(CClashedDependencyDescriptor* appendDepDesLinker, CClashedDependencyDescriptor* copyDepDesLinker, CCalculationAlgorithmContext* calcAlgContext) {
794 CClashedDependencyDescriptor* depDesLinker = appendDepDesLinker;
795 for (CClashedDependencyDescriptor* copyDepDesLinkerIt = copyDepDesLinker; copyDepDesLinkerIt; copyDepDesLinkerIt = copyDepDesLinkerIt->getNext()) {
796 depDesLinker = createClashedDependencyDescriptor(depDesLinker,copyDepDesLinkerIt->getDependencyTrackPoint(),calcAlgContext);
797 }
798 return depDesLinker;
799 }
800
801
802
803
804
805
806
807
808
809
810
811
812
813 CConceptDescriptor* CDatatypeIndividualProcessNodeHandler::triggerValueSpaceConcepts(CIndividualProcessNode* indiProcNode, CConceptDescriptor* appendConceptLinker, cint64& remainingRequiredValuesCount, CDatatypeValueSpaceData* valueSpaceData, CDatatypeValueSpaceType* valueSpaceType, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
814 CConceptDescriptor* triggerConcepts = nullptr;
815 CIndividualProcessNodeValueSpaceHandler* valueSpaceHandler = getValueSpaceHandler(valueSpaceType,calcAlgContext);
816 triggerConcepts = valueSpaceHandler->triggerValueSpaceConcepts(indiProcNode,appendConceptLinker,remainingRequiredValuesCount,depCollection,calcAlgContext);
817 return triggerConcepts;
818 }
819
820
821
822
823 }; // end namespace Algorithm
824
825 }; // end namespace Kernel
826
827 }; // end namespace Reasoner
828
829 }; // end namespace Konclude