Debian Codegraph @

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