Debian Codegraph @

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