Debian Codegraph @

Source/Reasoner/Kernel/Algorithm/CIndividualProcessNodeCompareValueSpaceHandler.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 "CIndividualProcessNodeCompareValueSpaceHandler.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Algorithm {
31
32
33 CIndividualProcessNodeCompareValueSpaceHandler::CIndividualProcessNodeCompareValueSpaceHandler(CDatatypeValueSpaceType* valueSpaceType) : CIndividualProcessNodeValueSpaceHandler(valueSpaceType) {
34 mCompareValueSpaceType = (CDatatypeValueSpaceCompareType*)valueSpaceType;
35 }
36
37
38
39 bool CIndividualProcessNodeCompareValueSpaceHandler::triggerDataLiteralConcept(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, bool otherValueSpacesClosed, bool* directlyTriggeredFlag, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
40
41 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
42 CDataLiteralCompareValue* dataLitCompareValue = dynamic_cast<CDataLiteralCompareValue*>(dataLitValue);
43 CMemoryTemporaryAllocationManager* taskMemMan = calcAlgContext->getUsedTemporaryMemoryAllocationManager();
44
45 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
46 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
47 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType, true);
48 if (!compareValueSpaceData->isValueSpaceClashed()) {
49 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(true);
50 if (otherValueSpacesClosed && directlyTriggeredFlag && compareValueSpaceMap->hasExcludedMinimum(dataLitCompareValue,false) && compareValueSpaceMap->hasExcludedMaximum(dataLitCompareValue,false)) {
51 compareValueSpaceMap->addValueSpaceDependencies(depCollection);
52 *directlyTriggeredFlag = true;
53 return false;
54 }
55
56 CDatatypeValueSpacesTriggers* valueSpacesTriggers = datatypesSpaceValue->getCustomValueSpacesTriggers(ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false),true);
57 CDatatypeValueSpaceCompareTriggers* compareValueSpaceTriggers = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(mCompareValueSpaceType);
58 CDatatypeValueSpaceConceptTriggerLinker* conceptTriggerLinker = CObjectAllocator< CDatatypeValueSpaceConceptTriggerLinker >::allocateAndConstruct(taskMemMan);
59 conceptTriggerLinker->initConceptTrigger(triggerConcept);
60 compareValueSpaceTriggers->addPartialValueConceptTrigger(dataLitCompareValue, conceptTriggerLinker);
61 compareValueSpaceData->setValueSpaceTriggeringRequired(true);
62 compareValueSpaceData->setValueSpaceTriggeringStarted(false);
63 compareValueSpaceData->setValueSpaceTriggeringCompleted(false);
64 return true;
65 }
66 return false;
67 }
68
69
70 bool CIndividualProcessNodeCompareValueSpaceHandler::triggerDatatypeConcept(CIndividualProcessNode* indiProcNode, CDatatype* datatype, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, bool otherValueSpacesClosed, bool* directlyTriggeredFlag, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
71
72 CMemoryTemporaryAllocationManager* taskMemMan = calcAlgContext->getUsedTemporaryMemoryAllocationManager();
73
74 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
75 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
76 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType, true);
77 if (!compareValueSpaceData->isValueSpaceClashed()) {
78
79 if (otherValueSpacesClosed) {
80 *directlyTriggeredFlag = true;
81 return false;
82 }
83
84 CDatatypeValueSpacesTriggers* valueSpacesTriggers = datatypesSpaceValue->getCustomValueSpacesTriggers(ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false), true);
85 CDatatypeValueSpaceCompareTriggers* compareValueSpaceTriggers = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(mCompareValueSpaceType);
86 CDatatypeValueSpaceConceptTriggerLinker* conceptTriggerLinker = CObjectAllocator< CDatatypeValueSpaceConceptTriggerLinker >::allocateAndConstruct(taskMemMan);
87 conceptTriggerLinker->initConceptTrigger(triggerConcept);
88 compareValueSpaceTriggers->addValueSpaceConceptTrigger(conceptTriggerLinker);
89 compareValueSpaceData->setValueSpaceTriggeringRequired(true);
90 compareValueSpaceData->setValueSpaceTriggeringStarted(false);
91 compareValueSpaceData->setValueSpaceTriggeringCompleted(false);
92 return true;
93 }
94 return false;
95 }
96
97
98 bool CIndividualProcessNodeCompareValueSpaceHandler::triggerDataRestrictionConcept(CIndividualProcessNode* indiProcNode, CConcept* dataRestricionConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CConcept* triggerConcept, bool otherValueSpacesClosed, bool* directlyTriggeredFlag, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
99 cint64 restrictionCode = dataRestricionConcept->getParameter();
100 CDatatype* datatype = dataRestricionConcept->getDatatype();
101 CDataLiteral* dataLiteral = dataRestricionConcept->getDataLiteral();
102 CDataLiteralValue* restrictionDataLitValue = nullptr;
103 if (dataLiteral) {
104 restrictionDataLitValue = dataLiteral->getDataLiteralValue();
105 }
106 CDataLiteralCompareValue* restrictionDataLitCompareValue = nullptr;
107 if (restrictionDataLitValue) {
108 restrictionDataLitCompareValue = dynamic_cast<CDataLiteralCompareValue*>(restrictionDataLitValue);
109 }
110 CMemoryTemporaryAllocationManager* taskMemMan = calcAlgContext->getUsedTemporaryMemoryAllocationManager();
111 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
112 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
113 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType, true);
114 if (!compareValueSpaceData->isValueSpaceClashed()) {
115 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(true);
116 bool directTriggering = false;
117 if (restrictionDataLitCompareValue) {
118 if (otherValueSpacesClosed && directlyTriggeredFlag) {
119 if (!negated) {
120 if (restrictionCode == CDFC_MIN_EXCLUSIVE) {
121 if (compareValueSpaceMap->hasExcludedMinimum(restrictionDataLitCompareValue, true)) {
122 directTriggering = true;
123 compareValueSpaceMap->addIntervalExclusionDependencies(mCompareValueSpaceType->getMinimumDataLiteralCompareValue(), true, restrictionDataLitCompareValue, true, depCollection);
124 }
125 } else if (restrictionCode == CDFC_MIN_INCLUSIVE) {
126 if (compareValueSpaceMap->hasExcludedMinimum(restrictionDataLitCompareValue, false)) {
127 directTriggering = true;
128 compareValueSpaceMap->addIntervalExclusionDependencies(mCompareValueSpaceType->getMinimumDataLiteralCompareValue(), true, restrictionDataLitCompareValue, false, depCollection);
129 }
130 } else if (restrictionCode == CDFC_MAX_INCLUSIVE) {
131 if (compareValueSpaceMap->hasExcludedMaximum(restrictionDataLitCompareValue, false)) {
132 directTriggering = true;
133 compareValueSpaceMap->addIntervalExclusionDependencies(restrictionDataLitCompareValue, false, mCompareValueSpaceType->getMaximumDataLiteralCompareValue(), true, depCollection);
134 }
135 } else if (restrictionCode == CDFC_MAX_EXCLUSIVE) {
136 if (compareValueSpaceMap->hasExcludedMaximum(restrictionDataLitCompareValue, true)) {
137 directTriggering = true;
138 compareValueSpaceMap->addIntervalExclusionDependencies(restrictionDataLitCompareValue, true, mCompareValueSpaceType->getMaximumDataLiteralCompareValue(), true, depCollection);
139 }
140 }
141 } else {
142 if (restrictionCode == CDFC_MIN_EXCLUSIVE) {
143 if (compareValueSpaceMap->hasExcludedMaximum(restrictionDataLitCompareValue, false)) {
144 directTriggering = true;
145 compareValueSpaceMap->addIntervalExclusionDependencies(restrictionDataLitCompareValue, false, mCompareValueSpaceType->getMaximumDataLiteralCompareValue(), true, depCollection);
146 }
147 } else if (restrictionCode == CDFC_MIN_INCLUSIVE) {
148 if (compareValueSpaceMap->hasExcludedMaximum(restrictionDataLitCompareValue, true)) {
149 directTriggering = true;
150 compareValueSpaceMap->addIntervalExclusionDependencies(restrictionDataLitCompareValue, true, mCompareValueSpaceType->getMaximumDataLiteralCompareValue(), true, depCollection);
151 }
152 } else if (restrictionCode == CDFC_MAX_INCLUSIVE) {
153 if (compareValueSpaceMap->hasExcludedMinimum(restrictionDataLitCompareValue, true)) {
154 directTriggering = true;
155 compareValueSpaceMap->addIntervalExclusionDependencies(mCompareValueSpaceType->getMinimumDataLiteralCompareValue(), true, restrictionDataLitCompareValue, true, depCollection);
156 }
157 } else if (restrictionCode == CDFC_MAX_EXCLUSIVE) {
158 if (compareValueSpaceMap->hasExcludedMinimum(restrictionDataLitCompareValue, false)) {
159 directTriggering = true;
160 compareValueSpaceMap->addIntervalExclusionDependencies(mCompareValueSpaceType->getMinimumDataLiteralCompareValue(), true, restrictionDataLitCompareValue, false, depCollection);
161 }
162 }
163 }
164 }
165
166
167 if (directTriggering) {
168 *directlyTriggeredFlag = true;
169 return false;
170 }
171
172
173 CDatatypeValueSpacesTriggers* valueSpacesTriggers = datatypesSpaceValue->getCustomValueSpacesTriggers(ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false), true);
174 CDatatypeValueSpaceCompareTriggers* compareValueSpaceTriggers = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(mCompareValueSpaceType);
175 CDatatypeValueSpaceConceptTriggerLinker* conceptTriggerLinker = CObjectAllocator< CDatatypeValueSpaceConceptTriggerLinker >::allocateAndConstruct(taskMemMan);
176 conceptTriggerLinker->initConceptTrigger(triggerConcept);
177
178 if (!negated) {
179 if (restrictionCode == CDFC_MIN_EXCLUSIVE) {
180 compareValueSpaceTriggers->addMinValueConceptTrigger(restrictionDataLitCompareValue, true, conceptTriggerLinker);
181 } else if (restrictionCode == CDFC_MIN_INCLUSIVE) {
182 compareValueSpaceTriggers->addMinValueConceptTrigger(restrictionDataLitCompareValue, false, conceptTriggerLinker);
183 } else if (restrictionCode == CDFC_MAX_INCLUSIVE) {
184 compareValueSpaceTriggers->addMaxValueConceptTrigger(restrictionDataLitCompareValue, false, conceptTriggerLinker);
185 } else if (restrictionCode == CDFC_MAX_EXCLUSIVE) {
186 compareValueSpaceTriggers->addMaxValueConceptTrigger(restrictionDataLitCompareValue, true, conceptTriggerLinker);
187 }
188 } else {
189 if (restrictionCode == CDFC_MIN_EXCLUSIVE) {
190 compareValueSpaceTriggers->addMaxValueConceptTrigger(restrictionDataLitCompareValue, false, conceptTriggerLinker);
191 } else if (restrictionCode == CDFC_MIN_INCLUSIVE) {
192 compareValueSpaceTriggers->addMaxValueConceptTrigger(restrictionDataLitCompareValue, true, conceptTriggerLinker);
193 } else if (restrictionCode == CDFC_MAX_INCLUSIVE) {
194 compareValueSpaceTriggers->addMinValueConceptTrigger(restrictionDataLitCompareValue, true, conceptTriggerLinker);
195 } else if (restrictionCode == CDFC_MAX_EXCLUSIVE) {
196 compareValueSpaceTriggers->addMinValueConceptTrigger(restrictionDataLitCompareValue, false, conceptTriggerLinker);
197 }
198 }
199 compareValueSpaceData->setValueSpaceTriggeringRequired(true);
200 compareValueSpaceData->setValueSpaceTriggeringStarted(false);
201 compareValueSpaceData->setValueSpaceTriggeringCompleted(false);
202
203 }
204
205 return true;
206 }
207 return false;
208
209 }
210
211
212
213 bool CIndividualProcessNodeCompareValueSpaceHandler::addDataLiteral(CIndividualProcessNode* indiProcNode, CDataLiteral* dataLiteral, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
214 CDataLiteralValue* dataLitValue = dataLiteral->getDataLiteralValue();
215 CDataLiteralCompareValue* dataLitCompareValue = dynamic_cast<CDataLiteralCompareValue*>(dataLitValue);
216
217 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
218 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,true);
219
220 bool newValuesPotentiallyExcluded = false;
221
222 if (!compareValueSpaceData->isValueSpaceClashed() && dataLitCompareValue) {
223 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(true);
224 if (!negated) {
225 newValuesPotentiallyExcluded |= compareValueSpaceMap->restrictToValue(dataLitCompareValue,depTrackPoint);
226 } else {
227 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeValue(dataLitCompareValue,depTrackPoint);
228 }
229 }
230 if (newValuesPotentiallyExcluded) {
231 datatypesSpaceValue->setValueSapceModified(compareValueSpaceData);
232 compareValueSpaceData->setValueSpaceInitialisationDependencyTrackPointCandidate(depTrackPoint);
233 }
234
235 return newValuesPotentiallyExcluded;
236 }
237
238
239
240
241 bool CIndividualProcessNodeCompareValueSpaceHandler::addDataRestriction(CIndividualProcessNode* indiProcNode, CConcept* dataRestricionConcept, bool negated, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContext* calcAlgContext) {
242 CDatatype* datatype = dataRestricionConcept->getDatatype();
243 cint64 restrictionCode = dataRestricionConcept->getParameter();
244 CDataLiteral* dataLiteral = dataRestricionConcept->getDataLiteral();
245
246 CDataLiteralValue* restrictionDataLitValue = nullptr;
247 if (dataLiteral) {
248 restrictionDataLitValue = dataLiteral->getDataLiteralValue();
249 }
250 CDataLiteralCompareValue* restrictionDataLitCompareValue = nullptr;
251 if (restrictionDataLitValue) {
252 restrictionDataLitCompareValue = dynamic_cast<CDataLiteralCompareValue*>(restrictionDataLitValue);
253 }
254
255 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
256 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,true);
257
258 if (compareValueSpaceData->isValueSpaceClashed()) {
259 return false;
260 }
261
262 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(true);
263
264 bool newValuesPotentiallyExcluded = false;
265 if (restrictionDataLitCompareValue) {
266 if (!negated) {
267 if (restrictionCode == CDFC_MIN_EXCLUSIVE) {
268 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMinimum(restrictionDataLitCompareValue,true,depTrackPoint);
269 } else if (restrictionCode == CDFC_MIN_INCLUSIVE) {
270 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMinimum(restrictionDataLitCompareValue,false,depTrackPoint);
271 } else if (restrictionCode == CDFC_MAX_INCLUSIVE) {
272 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMaximum(restrictionDataLitCompareValue,false,depTrackPoint);
273 } else if (restrictionCode == CDFC_MAX_EXCLUSIVE) {
274 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMaximum(restrictionDataLitCompareValue,true,depTrackPoint);
275 }
276 } else {
277 if (restrictionCode == CDFC_MIN_EXCLUSIVE) {
278 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMaximum(restrictionDataLitCompareValue,false,depTrackPoint);
279 } else if (restrictionCode == CDFC_MIN_INCLUSIVE) {
280 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMaximum(restrictionDataLitCompareValue,true,depTrackPoint);
281 } else if (restrictionCode == CDFC_MAX_INCLUSIVE) {
282 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMinimum(restrictionDataLitCompareValue,true,depTrackPoint);
283 } else if (restrictionCode == CDFC_MAX_EXCLUSIVE) {
284 newValuesPotentiallyExcluded |= compareValueSpaceMap->excludeMinimum(restrictionDataLitCompareValue,false,depTrackPoint);
285 }
286 }
287 }
288
289 if (newValuesPotentiallyExcluded) {
290 datatypesSpaceValue->setValueSapceModified(compareValueSpaceData);
291 compareValueSpaceData->setValueSpaceInitialisationDependencyTrackPointCandidate(depTrackPoint);
292 }
293
294 return newValuesPotentiallyExcluded;
295 }
296
297
298
299
300
301
302
303
304
305 bool CIndividualProcessNodeCompareValueSpaceHandler::testValueSpaceClashed(CIndividualProcessNode* indiProcNode, CCalculationAlgorithmContext* calcAlgContext) {
306 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
307
308 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,false);
309 if (compareValueSpaceData) {
310 if (compareValueSpaceData->isValueSpaceClashed()) {
311 return true;
312 }
313 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(false);
314 if (compareValueSpaceMap) {
315 bool clashed = compareValueSpaceMap->testValueSpaceReturnClashed();
316 if (clashed) {
317 compareValueSpaceMap->addValueSpaceDependencies(compareValueSpaceData->getClashDependencyTrackPointCollection());
318 compareValueSpaceData->setValueSpaceClashed(true);
319 return true;
320 }
321 }
322 }
323 return false;
324 }
325
326
327
328 bool CIndividualProcessNodeCompareValueSpaceHandler::addValueSpaceDependencies(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceDependencyCollector* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
329 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
330
331 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,false);
332 if (compareValueSpaceData) {
333 if (!compareValueSpaceData->isValueSpaceClashed()) {
334 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(false);
335 if (compareValueSpaceMap) {
336 return compareValueSpaceMap->addValueSpaceDependencies(depCollection);
337 }
338 } else {
339 return compareValueSpaceData->getClashDependencyTrackPointCollection()->addCollectionDependencies(depCollection);
340 }
341 }
342 return false;
343 }
344
345
346 bool CIndividualProcessNodeCompareValueSpaceHandler::countPossibleValueSpaceValues(CIndividualProcessNode* indiProcNode, CDatatypeValueSpaceValuesCounter* valueCounter, CCalculationAlgorithmContext* calcAlgContext) {
347 bool counted = false;
348 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
349 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,false);
350 if (compareValueSpaceData) {
351 if (!compareValueSpaceData->isValueSpaceClashed()) {
352 if (!compareValueSpaceData->isValueSpaceCounted() || compareValueSpaceData->isValueSpaceCountingRequired()) {
353 compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,true);
354 CDatatypeValueSpaceValuesCounter* valueSpaceValueCounter = compareValueSpaceData->getValuesCounter();
355 valueSpaceValueCounter->resetValueCounter();
356 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(false);
357 if (compareValueSpaceMap) {
358 compareValueSpaceMap->countAllValues(valueSpaceValueCounter);
359 } else {
360 if (mCompareValueSpaceType->hasInfiniteManyValues()) {
361 valueSpaceValueCounter->incInfinite();
362 } else {
363 valueSpaceValueCounter->incValueCount(mCompareValueSpaceType->getMaximumValueCount());
364 }
365 }
366 compareValueSpaceData->setValueSpaceCounted(true);
367 compareValueSpaceData->setValueSpaceCountingRequired(false);
368 if (valueCounter) {
369 counted = valueCounter->combineWithValueCounter(valueSpaceValueCounter);
370 }
371 } else {
372 CDatatypeValueSpaceValuesCounter* valueSpaceValueCounter = compareValueSpaceData->getValuesCounter();
373 if (valueCounter) {
374 counted = valueCounter->combineWithValueCounter(valueSpaceValueCounter);
375 }
376 }
377 }
378 } else {
379 if (valueCounter) {
380 counted = valueCounter->incInfinite();
381 }
382 }
383 return counted;
384 }
385
386
387 CConceptDescriptor* CIndividualProcessNodeCompareValueSpaceHandler::triggerValueSpaceConcepts(CIndividualProcessNode* indiProcNode, CConceptDescriptor* appendConceptLinker, cint64& remainingRequiredValuesCount, CDatatypeDependencyCollection* depCollection, CCalculationAlgorithmContext* calcAlgContext) {
388 CConceptDescriptor* conceptTriggerLinker = appendConceptLinker;
389 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
390
391 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
392 bool substractValueSpaceValuesCount = false;
393
394 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,false);
395 if (!compareValueSpaceData || (!compareValueSpaceData->isValueSpaceClashed() && !compareValueSpaceData->isValueSpaceTriggeringCompleted())) {
396 compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,true);
397 bool valueSpaceTriggeringFinished = false;
398 if (!compareValueSpaceData->isValueSpaceTriggeringStarted()) {
399 compareValueSpaceData->setValueSpaceTriggeringStarted(true);
400 }
401 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(true);
402
403 CDatatypeValueSpacesTriggers* valueSpacesTriggers = datatypesSpaceValue->getCustomValueSpacesTriggers(ontology->getDataBoxes()->getMBox()->getValueSpacesTriggers(false));
404 if (valueSpacesTriggers) {
405
406 CDatatypeValueSpaceCompareTriggers* compareValueSpaceTriggers = (CDatatypeValueSpaceCompareTriggers*)valueSpacesTriggers->getValueSpaceTriggers(mCompareValueSpaceType);
407 CDatatypeValueSpaceTriggeringMap* compareValueSpaceTriggerMap = compareValueSpaceTriggers->getValueSpaceTriggeringMap();
408
409 depCollection->addDependency(compareValueSpaceData->getValueSpaceInitialisationDependencyTrackPoint());
410
411 CDatatypeValueSpaceConceptTriggeringData* valueSpaceConceptTriggeringData = compareValueSpaceTriggers->getValueSpaceConceptTriggeringData();
412 if (valueSpaceConceptTriggeringData->hasPartialConceptTriggers()) {
413 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,valueSpaceConceptTriggeringData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
414 }
415
416
417
418
419 CDataLiteralCompareValue* minValue = nullptr;
420 bool minValueInclusive = false;
421 CDependencyTrackPoint* minValueDepTrackPoint = nullptr;
422
423
424 if (compareValueSpaceMap->getAbsoluteMinimumValue(minValue,minValueInclusive,&minValueDepTrackPoint)) {
425
426
427 CDatatypeDependencyCollection minValueDepCollection(depCollection,calcAlgContext);
428
429 bool minDatatypeDepAdded = false;
430
431 CDatatypeValueSpaceTriggeringIterator leftTriggerIt = compareValueSpaceTriggerMap->getLeftTriggeringIterator(minValue,!minValueInclusive);
432 while (leftTriggerIt.hasNext()) {
433 CDatatypeValueSpaceTriggeringData* triggeringData = leftTriggerIt.next();
434 CDatatypeValueSpaceConceptTriggeringData* minExcTriggeringConceptData = triggeringData->getMinExclusiveTriggeringData();
435 CDatatypeValueSpaceConceptTriggeringData* minIncTriggeringConceptData = triggeringData->getMinInclusiveTriggeringData();
436 if (minExcTriggeringConceptData->hasPartialConceptTriggers() || minIncTriggeringConceptData->hasPartialConceptTriggers()) {
437 if (!minDatatypeDepAdded && minValueDepTrackPoint) {
438 minDatatypeDepAdded = true;
439 minValueDepCollection.addDependency(minValueDepTrackPoint);
440 }
441 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minExcTriggeringConceptData->getPartialConceptTriggerLinker(),&minValueDepCollection,calcAlgContext);
442 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minIncTriggeringConceptData->getPartialConceptTriggerLinker(),&minValueDepCollection,calcAlgContext);
443 }
444 }
445
446 CDatatypeValueSpaceTriggeringData* minValueTriggerData = compareValueSpaceTriggerMap->getDatatypeValueTriggeringData(minValue,false);
447 if (minValueTriggerData) {
448 CDatatypeValueSpaceConceptTriggeringData* minTriggeringConceptData = nullptr;
449 if (!minValueInclusive) {
450 minTriggeringConceptData = minValueTriggerData->getMinExclusiveTriggeringData();
451 } else {
452 minTriggeringConceptData = minValueTriggerData->getMinInclusiveTriggeringData();
453 }
454 if (minTriggeringConceptData->hasPartialConceptTriggers()) {
455 if (!minDatatypeDepAdded && minValueDepTrackPoint) {
456 minDatatypeDepAdded = true;
457 minValueDepCollection.addDependency(minValueDepTrackPoint);
458 }
459 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minTriggeringConceptData->getPartialConceptTriggerLinker(),&minValueDepCollection,calcAlgContext);
460 }
461 }
462 }
463
464
465
466
467 CDataLiteralCompareValue* maxValue = nullptr;
468 bool maxValueInclusive = false;
469 CDependencyTrackPoint* maxValueDepTrackPoint = nullptr;
470 if (compareValueSpaceMap->getAbsoluteMaximumValue(maxValue,maxValueInclusive,&maxValueDepTrackPoint)) {
471
472 CDatatypeDependencyCollection maxValueDepCollection(depCollection,calcAlgContext);
473
474 bool maxDatatypeDepAdded = false;
475
476 CDatatypeValueSpaceTriggeringIterator rightTriggerIt = compareValueSpaceTriggerMap->getRightTriggeringIterator(maxValue,!maxValueInclusive);
477 while (rightTriggerIt.hasNext()) {
478 CDatatypeValueSpaceTriggeringData* triggeringData = rightTriggerIt.next();
479 CDatatypeValueSpaceConceptTriggeringData* maxExcTriggeringConceptData = triggeringData->getMaxExclusiveTriggeringData();
480 CDatatypeValueSpaceConceptTriggeringData* maxIncTriggeringConceptData = triggeringData->getMaxInclusiveTriggeringData();
481 if (maxExcTriggeringConceptData->hasPartialConceptTriggers() || maxIncTriggeringConceptData->hasPartialConceptTriggers()) {
482 if (!maxDatatypeDepAdded && maxValueDepTrackPoint) {
483 maxDatatypeDepAdded = true;
484 maxValueDepCollection.addDependency(minValueDepTrackPoint);
485 }
486 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxExcTriggeringConceptData->getPartialConceptTriggerLinker(),&maxValueDepCollection,calcAlgContext);
487 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxIncTriggeringConceptData->getPartialConceptTriggerLinker(),&maxValueDepCollection,calcAlgContext);
488 }
489 }
490
491
492 CDatatypeValueSpaceTriggeringData* maxValueTriggerData = compareValueSpaceTriggerMap->getDatatypeValueTriggeringData(maxValue,false);
493 if (maxValueTriggerData) {
494 CDatatypeValueSpaceConceptTriggeringData* maxTriggeringConceptData = nullptr;
495 if (!maxValueInclusive) {
496 maxTriggeringConceptData = maxValueTriggerData->getMaxExclusiveTriggeringData();
497 } else {
498 maxTriggeringConceptData = maxValueTriggerData->getMaxInclusiveTriggeringData();
499 }
500 if (maxTriggeringConceptData->hasPartialConceptTriggers()) {
501 if (!maxDatatypeDepAdded && maxValueDepTrackPoint) {
502 maxDatatypeDepAdded = true;
503 maxValueDepCollection.addDependency(maxValueDepTrackPoint);
504 }
505 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxTriggeringConceptData->getPartialConceptTriggerLinker(),&maxValueDepCollection,calcAlgContext);
506 }
507 }
508 }
509
510
511
512 if (minValue && maxValue) {
513
514 CDatatypeValueSpaceValuesCounter valueCounter;
515
516
517 CDataLiteralCompareValue* freeLeftValue = nullptr;
518 CDataLiteralCompareValue* freeRightValue = nullptr;
519 bool freeLeftValueInclusive = false;
520 bool freeRightValueInclusive = false;
521
522 if (compareValueSpaceTriggerMap->getIntervalMinMaxTriggerFreeInterval(minValue,minValueInclusive,maxValue,maxValueInclusive,freeLeftValue,freeLeftValueInclusive,freeRightValue,freeRightValueInclusive)) {
523 if (freeLeftValue && freeRightValue) {
524 CDatatypeValueSpaceValuesCounter tmpValueCounter;
525 if (compareValueSpaceMap->countIntervalValues(freeLeftValue,freeLeftValueInclusive,freeRightValue,freeRightValueInclusive,&tmpValueCounter)) {
526 cint64 triggerValueCount = 0;
527 if (compareValueSpaceTriggerMap->countIntervalValueTriggers(minValue,minValueInclusive,maxValue,maxValueInclusive,triggerValueCount)) {
528 valueCounter.combineWithValueCounter(&tmpValueCounter,triggerValueCount);
529 }
530 }
531 }
532 }
533
534
535 if (!valueCounter.hasValueAchieved(remainingRequiredValuesCount)) {
536
537
538 bool minToMaxTriggerDirection = true;
539
540 cint64 minTriggerCount = 0;
541 cint64 maxTriggerCount = 0;
542 cint64 valueTriggerCount = 0;
543 compareValueSpaceTriggerMap->countIntervalMinMaxValueTriggers(minValue,minValueInclusive,maxValue,maxValueInclusive,minTriggerCount,maxTriggerCount,valueTriggerCount);
544
545 if (minTriggerCount < maxTriggerCount) {
546 minToMaxTriggerDirection = false;
547 }
548
549 depCollection->addDependency(minValueDepTrackPoint);
550 depCollection->addDependency(maxValueDepTrackPoint);
551
552 CDatatypeValueSpaceTriggeringIterator triggerIt = compareValueSpaceTriggerMap->getIntervalTriggeringIterator(minValue,minValueInclusive,maxValue,maxValueInclusive,minToMaxTriggerDirection);
553
554 if (minTriggerCount > 0 && maxTriggerCount > 0) {
555
556
557 CDatatypeValueSpaceTriggeringIterator minMaxDirectionTriggerIt = triggerIt;
558 while (minMaxDirectionTriggerIt.hasNext()) {
559
560 CDatatypeValueSpaceTriggeringData* triggeringData = minMaxDirectionTriggerIt.next();
561 if (minToMaxTriggerDirection) {
562 CDatatypeValueSpaceConceptTriggeringData* maxExcTriggeringConceptData = triggeringData->getMaxExclusiveTriggeringData();
563 CDatatypeValueSpaceConceptTriggeringData* maxIncTriggeringConceptData = triggeringData->getMaxInclusiveTriggeringData();
564 if (maxExcTriggeringConceptData->hasPartialConceptTriggers() || maxIncTriggeringConceptData->hasPartialConceptTriggers()) {
565 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxExcTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
566 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxIncTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
567 }
568
569 } else {
570
571 CDatatypeValueSpaceConceptTriggeringData* minExcTriggeringConceptData = triggeringData->getMinExclusiveTriggeringData();
572 CDatatypeValueSpaceConceptTriggeringData* minIncTriggeringConceptData = triggeringData->getMinInclusiveTriggeringData();
573 if (minExcTriggeringConceptData->hasPartialConceptTriggers() || minIncTriggeringConceptData->hasPartialConceptTriggers()) {
574 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minExcTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
575 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minIncTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
576 }
577
578 }
579 }
580 }
581
582
583 if (!minValue->isEqualTo(maxValue)) {
584 CDataLiteralCompareValue* lastValue = nullptr;
585 if (minToMaxTriggerDirection) {
586 lastValue = minValue;
587 } else {
588 lastValue = maxValue;
589 }
590
591
592 CDatatypeValueSpaceTriggeringIterator stepMinMaxDirectionTriggerIt = triggerIt;
593 while (!valueCounter.hasValueAchieved(remainingRequiredValuesCount) && stepMinMaxDirectionTriggerIt.hasNext()) {
594
595 CDatatypeValueSpaceTriggeringData* triggeringData = stepMinMaxDirectionTriggerIt.next();
596 CDataLiteralCompareValue* currentValue = triggeringData->getValue();
597
598
599 if (lastValue && !lastValue->isEqualTo(currentValue)) {
600 if (minToMaxTriggerDirection) {
601 compareValueSpaceMap->countIntervalValues(lastValue,false,currentValue,false,&valueCounter);
602 compareValueSpaceMap->addIntervalExclusionDependencies(lastValue,false,currentValue,false,depCollection);
603 } else {
604 compareValueSpaceMap->countIntervalValues(currentValue,false,lastValue,false,&valueCounter);
605 compareValueSpaceMap->addIntervalExclusionDependencies(currentValue,false,lastValue,false,depCollection);
606 }
607 }
608
609 if (minToMaxTriggerDirection) {
610 CDatatypeValueSpaceConceptTriggeringData* minExcTriggeringConceptData = triggeringData->getMinExclusiveTriggeringData();
611 if (minExcTriggeringConceptData->hasPartialConceptTriggers()) {
612 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minExcTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
613 }
614 } else {
615 CDatatypeValueSpaceConceptTriggeringData* maxExcTriggeringConceptData = triggeringData->getMaxExclusiveTriggeringData();
616 if (maxExcTriggeringConceptData->hasPartialConceptTriggers()) {
617 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxExcTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
618 }
619 }
620
621 if (!triggeringData->getDirectValueTriggeringData()->hasPartialConceptTriggers()) {
622 compareValueSpaceMap->countValueValues(currentValue,&valueCounter);
623 compareValueSpaceMap->addValueExclusionDependencies(currentValue,depCollection);
624 }
625
626
627 if (!valueCounter.hasValueAchieved(remainingRequiredValuesCount)) {
628
629 if (minToMaxTriggerDirection) {
630 CDatatypeValueSpaceConceptTriggeringData* minIncTriggeringConceptData = triggeringData->getMinInclusiveTriggeringData();
631 if (minIncTriggeringConceptData->hasPartialConceptTriggers()) {
632 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,minIncTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
633 }
634 } else {
635 CDatatypeValueSpaceConceptTriggeringData* maxIncTriggeringConceptData = triggeringData->getMaxInclusiveTriggeringData();
636 if (maxIncTriggeringConceptData->hasPartialConceptTriggers()) {
637 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,maxIncTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
638 }
639 }
640 }
641 }
642 }
643
644
645
646 if (minValue->isEqualTo(maxValue) && remainingRequiredValuesCount == 1 && !valueCounter.hasValueAchieved(remainingRequiredValuesCount) && triggerIt.hasNext()) {
647
648 CDatatypeValueSpaceTriggeringIterator valueDirectionTriggerIt = triggerIt;
649 CDatatypeValueSpaceTriggeringData* triggeringData = valueDirectionTriggerIt.next();
650 CDataLiteralCompareValue* currentValue = triggeringData->getValue();
651
652 if (triggeringData->getDirectValueTriggeringData()->hasCompleteConceptTriggers() || triggeringData->getDirectValueTriggeringData()->hasPartialConceptTriggers()) {
653 compareValueSpaceMap->addValueExclusionDependencies(currentValue, depCollection);
654
655 if (!compareValueSpaceMap->isValueExcluded(currentValue)) {
656 compareValueSpaceMap->countValueValues(currentValue, &valueCounter);
657
658 CDatatypeValueSpaceConceptTriggeringData* directValueTriggeringConceptData = triggeringData->getDirectValueTriggeringData();
659 if (directValueTriggeringConceptData->hasCompleteConceptTriggers()) {
660 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode, conceptTriggerLinker, directValueTriggeringConceptData->getCompleteConceptTriggerLinker(), depCollection, calcAlgContext);
661 }
662 if (directValueTriggeringConceptData->hasPartialConceptTriggers()) {
663 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode, conceptTriggerLinker, directValueTriggeringConceptData->getPartialConceptTriggerLinker(), depCollection, calcAlgContext);
664 }
665
666 }
667 }
668
669 } else {
670
671
672
673 CDatatypeValueSpaceTriggeringIterator valueDirectionTriggerIt = triggerIt;
674 while (!valueCounter.hasValueAchieved(remainingRequiredValuesCount) && valueDirectionTriggerIt.hasNext()) {
675
676 CDatatypeValueSpaceTriggeringData* triggeringData = valueDirectionTriggerIt.next();
677 CDataLiteralCompareValue* currentValue = triggeringData->getValue();
678
679 if (triggeringData->getDirectValueTriggeringData()->hasPartialConceptTriggers()) {
680 compareValueSpaceMap->addValueExclusionDependencies(currentValue,depCollection);
681 if (!compareValueSpaceMap->isValueExcluded(currentValue)) {
682 compareValueSpaceMap->countValueValues(currentValue,&valueCounter);
683
684 CDatatypeValueSpaceConceptTriggeringData* directValueTriggeringConceptData = triggeringData->getDirectValueTriggeringData();
685 if (directValueTriggeringConceptData->hasPartialConceptTriggers()) {
686 conceptTriggerLinker = addConceptLinkerCollectionDependency(indiProcNode,conceptTriggerLinker,directValueTriggeringConceptData->getPartialConceptTriggerLinker(),depCollection,calcAlgContext);
687 }
688 }
689 }
690 }
691 }
692
693
694
695 }
696
697
698
699 remainingRequiredValuesCount -= valueCounter.getValueCount();
700 if (valueCounter.isInfinite()) {
701 remainingRequiredValuesCount = 0;
702 }
703 if (remainingRequiredValuesCount < 0) {
704 remainingRequiredValuesCount = 0;
705 }
706
707 if (remainingRequiredValuesCount > 0) {
708 valueSpaceTriggeringFinished = true;
709 }
710
711
712 }
713
714 } else {
715 valueSpaceTriggeringFinished = true;
716 substractValueSpaceValuesCount = true;
717 }
718
719 if (valueSpaceTriggeringFinished) {
720 if (!compareValueSpaceData->isValueSpaceTriggeringCompleted()) {
721 compareValueSpaceData->setValueSpaceTriggeringCompleted(true);
722 }
723 }
724 } else {
725 substractValueSpaceValuesCount = true;
726 }
727
728
729 if (substractValueSpaceValuesCount) {
730 CDatatypeValueSpaceValuesCounter valueCounter;
731 countPossibleValueSpaceValues(indiProcNode,&valueCounter,calcAlgContext);
732 if (valueCounter.isInfinite()) {
733 remainingRequiredValuesCount = 0;
734 } else {
735 remainingRequiredValuesCount -= valueCounter.getValueCount();
736 if (remainingRequiredValuesCount <= 0) {
737 remainingRequiredValuesCount = 0;
738 } else {
739 addValueSpaceDependencies(indiProcNode,depCollection,calcAlgContext);
740 }
741 }
742 }
743
744 return conceptTriggerLinker;
745 }
746
747
748
749
750 bool CIndividualProcessNodeCompareValueSpaceHandler::getNextPossibleDataValue(CIndividualProcessNode* indiProcNode, CDataLiteralValue*& nextValue, CDataLiteralValue* lastValue, CDatatypeValueTestingCollection* valueTestingCollection, CCalculationAlgorithmContext* calcAlgContext) {
751
752 CDataLiteralCompareValue* lastCompareValue = nullptr;
753 if (lastValue) {
754 lastCompareValue = dynamic_cast<CDataLiteralCompareValue*>(lastValue);
755 }
756
757
758 CDatatypesValueSpaceData* datatypesSpaceValue = indiProcNode->getDatatypesValueSpaceData(true);
759 CConcreteOntology* ontology = calcAlgContext->getUsedProcessingDataBox()->getOntology();
760
761 CDatatypeCompareValueSpaceData* compareValueSpaceData = (CDatatypeCompareValueSpaceData*)datatypesSpaceValue->getValueSpace(mCompareValueSpaceType,true);
762 if (compareValueSpaceData && !compareValueSpaceData->isValueSpaceClashed()) {
763 CDataLiteralValue* tmpNextValue = valueTestingCollection->createDataLiteralValue(mCompareValueSpaceType);
764 CDataLiteralCompareValue* nextCompareValue = dynamic_cast<CDataLiteralCompareValue*>(tmpNextValue);
765
766 CDataLiteralValue* tmpLastValue = nullptr;
767 CDataLiteralCompareValue* tmpLastCompareValue = nullptr;
768 if (lastCompareValue) {
769 tmpLastValue = valueTestingCollection->createDataLiteralValue(mCompareValueSpaceType);
770 tmpLastCompareValue = dynamic_cast<CDataLiteralCompareValue*>(tmpLastValue);
771 tmpLastCompareValue->initValue(lastCompareValue);
772 }
773
774 CDatatypeCompareValueSpaceMap* compareValueSpaceMap = compareValueSpaceData->getValueSpaceMap(true);
775 bool searchNextValue = true;
776 while (searchNextValue) {
777 if (compareValueSpaceMap->getNextPossibleDataValue(nextCompareValue,tmpLastCompareValue)) {
778 if (!valueTestingCollection->isDataLiteralValueUsed(tmpNextValue,mCompareValueSpaceType)) {
779 valueTestingCollection->releaseDataLiteralValue(tmpLastValue,mCompareValueSpaceType);
780 nextValue = tmpNextValue;
781 return true;
782 }
783 } else {
784 searchNextValue = false;
785 }
786 if (!tmpLastCompareValue) {
787 tmpLastValue = valueTestingCollection->createDataLiteralValue(mCompareValueSpaceType);
788 tmpLastCompareValue = dynamic_cast<CDataLiteralCompareValue*>(tmpLastValue);
789 tmpLastCompareValue->initValue(nextCompareValue);
790 } else {
791 tmpLastCompareValue->initValue(nextCompareValue);
792 }
793 }
794 if (!searchNextValue) {
795 valueTestingCollection->releaseDataLiteralValue(tmpNextValue,mCompareValueSpaceType);
796 valueTestingCollection->releaseDataLiteralValue(tmpLastValue,mCompareValueSpaceType);
797 }
798 }
799 return false;
800 }
801
802
803 }; // end namespace Algorithm
804
805 }; // end namespace Kernel
806
807 }; // end namespace Reasoner
808
809 }; // end namespace Konclude