Debian Codegraph @

Source/Reasoner/Kernel/Process/CDatatypeStringValueSpaceMap.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 "CDatatypeStringValueSpaceMap.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CDatatypeStringValueSpaceMap::CDatatypeStringValueSpaceMap(CProcessContext* processContext) : CPROCESSMAP<CDatatypeStringValueSpaceMapArranger,CDatatypeStringValueSpaceMapData>(processContext),mProcessContext(processContext) {
34 }
35
36
37 CDatatypeStringValueSpaceMap* CDatatypeStringValueSpaceMap::initDatatypeStringValueSpaceMap(CDatatypeStringValueSpaceMap* map) {
38 if (map) {
39 CPROCESSMAP<CDatatypeStringValueSpaceMapArranger, CDatatypeStringValueSpaceMapData>::operator=(*map);
40 mAbsoluteMinimumExclusionValue = map->mAbsoluteMinimumExclusionValue;
41 mAbsoluteMaximumExclusionValue = map->mAbsoluteMaximumExclusionValue;
42 }
43 return this;
44 }
45
46
47
48 CDatatypeStringValueSpaceMap* CDatatypeStringValueSpaceMap::initDatatypeStringValueSpaceMap(CDatatypeValueSpaceStringType* valueSpaceType) {
49 CPROCESSMAP<CDatatypeStringValueSpaceMapArranger,CDatatypeStringValueSpaceMapData>::clear();
50 mAbsoluteMinimumExclusionValue = nullptr;
51 mAbsoluteMaximumExclusionValue = nullptr;
52
53 excludeMinimum(valueSpaceType->getMinimumDataLiteralStringValue(),false,nullptr);
54 excludeMaximum(valueSpaceType->getMaximumDataLiteralStringValue(),false,nullptr);
55 return this;
56 }
57
58
59
60 bool CDatatypeStringValueSpaceMap::getAbsoluteMinimumValue(CDataLiteralStringValue*& minValue, bool& minValueInclusive, CDependencyTrackPoint** depTrackPoint) {
61 if (mAbsoluteMinimumExclusionValue) {
62 minValue = mAbsoluteMinimumExclusionValue->getValue();
63 minValueInclusive = true;
64 if (depTrackPoint) {
65 *depTrackPoint = mAbsoluteMinimumExclusionValue->getLeftExclusionData()->getExcludedDependencyTrackPoint();
66 }
67 if (mAbsoluteMinimumExclusionValue->getValueExclusionData()->isExcluded()) {
68 if (mAbsoluteMinimumExclusionValue->getValueExclusionData()->getExcludedDependencyTrackPoint() == mAbsoluteMinimumExclusionValue->getLeftExclusionData()->getExcludedDependencyTrackPoint()) {
69 minValueInclusive = false;
70 }
71 }
72 return true;
73 }
74 return false;
75 }
76
77
78 bool CDatatypeStringValueSpaceMap::getAbsoluteMaximumValue(CDataLiteralStringValue*& maxValue, bool& maxValueInclusive, CDependencyTrackPoint** depTrackPoint) {
79 if (mAbsoluteMaximumExclusionValue) {
80 maxValue = mAbsoluteMaximumExclusionValue->getValue();
81 maxValueInclusive = true;
82 if (depTrackPoint) {
83 *depTrackPoint = mAbsoluteMaximumExclusionValue->getRightExclusionData()->getExcludedDependencyTrackPoint();
84 }
85 if (mAbsoluteMaximumExclusionValue->getValueExclusionData()->isExcluded()) {
86 if (mAbsoluteMaximumExclusionValue->getValueExclusionData()->getExcludedDependencyTrackPoint() == mAbsoluteMaximumExclusionValue->getRightExclusionData()->getExcludedDependencyTrackPoint()) {
87 maxValueInclusive = false;
88 }
89 }
90 return true;
91 }
92 return false;
93 }
94
95
96
97 bool CDatatypeStringValueSpaceMap::excludeMinimum(CDataLiteralStringValue* value, bool valueInclusively, CDependencyTrackPoint* depTrackPoint) {
98
99 if (mAbsoluteMinimumExclusionValue) {
100 if (mAbsoluteMinimumExclusionValue->getValue()->isGreaterThan(value)) {
101 return false;
102 }
103 }
104 bool newValuesPotentiallyExcluded = false;
105
106 CDatatypeStringValueData* valueData = getDatatypeStringValueData(value,true);
107 newValuesPotentiallyExcluded |= excludeLeftDataInterval(valueData,depTrackPoint,nullptr,true);
108 if (valueInclusively && !isDataValueExcluded(valueData,nullptr)) {
109 newValuesPotentiallyExcluded |= excludeDataValue(valueData,depTrackPoint,nullptr,false);
110 }
111 mAbsoluteMinimumExclusionValue = valueData;
112
113 // remove all lower values from map
114 CDatatypeStringValueSpaceMap::iterator it = CDatatypeStringValueSpaceMap::begin(), itEnd = CDatatypeStringValueSpaceMap::end();
115 while (it != itEnd) {
116 const CDatatypeStringValueSpaceMapData& mapData = it.value();
117 CDatatypeStringValueData* itValueData = mapData.mUseValue;
118 if (itValueData == valueData) {
119 break;
120 }
121 newValuesPotentiallyExcluded = true;
122 it = CDatatypeStringValueSpaceMap::erase(it);
123 }
124
125 return newValuesPotentiallyExcluded;
126 }
127
128
129
130 bool CDatatypeStringValueSpaceMap::excludeMaximum(CDataLiteralStringValue* value, bool valueInclusively, CDependencyTrackPoint* depTrackPoint) {
131
132 if (mAbsoluteMaximumExclusionValue) {
133 if (mAbsoluteMaximumExclusionValue->getValue()->isLessThan(value)) {
134 return false;
135 }
136 }
137 bool newValuesPotentiallyExcluded = false;
138
139 CDatatypeStringValueData* valueData = getDatatypeStringValueData(value,true);
140 newValuesPotentiallyExcluded |= excludeRightDataInterval(valueData,depTrackPoint,nullptr,true);
141 if (valueInclusively && !isDataValueExcluded(valueData,nullptr)) {
142 newValuesPotentiallyExcluded |= excludeDataValue(valueData,depTrackPoint,nullptr,false);
143 }
144 mAbsoluteMaximumExclusionValue = valueData;
145
146 // remove all higher values from map
147 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
148 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itUB = CDatatypeStringValueSpaceMap::upperBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
149 CDatatypeStringValueSpaceMap::iterator it = itUB;
150 while (it != itEnd) {
151 const CDatatypeStringValueSpaceMapData& mapData = it.value();
152 CDatatypeStringValueData* itValueData = mapData.mUseValue;
153 it = CDatatypeStringValueSpaceMap::erase(it);
154 newValuesPotentiallyExcluded = true;
155 }
156
157
158
159 return newValuesPotentiallyExcluded;
160 }
161
162
163
164
165
166
167
168
169
170
171 bool CDatatypeStringValueSpaceMap::excludeMinimum(CDataLiteralStringValue* value, bool valueInclusively, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType) {
172 bool newValuesPotentiallyExcluded = false;
173
174 CDatatypeStringValueData* valueData = getDatatypeStringValueData(value,true);
175 if (valueInclusively && !isDataValueExcluded(valueData,exclusionType)) {
176 newValuesPotentiallyExcluded |= excludeDataValue(valueData,depTrackPoint,exclusionType,false);
177 }
178
179 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itEnd = CDatatypeStringValueSpaceMap::end();
180 CDatatypeStringValueSpaceMap::iterator it = itBegin;
181 while (it != itEnd) {
182 CDatatypeStringValueSpaceMapData& mapData = it.value();
183 CDatatypeStringValueData* itValueData = mapData.mUseValue;
184
185 if (it == itBegin) {
186 if (!isLeftDataIntervalExcluded(itValueData,exclusionType)) {
187 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
188 newValuesPotentiallyExcluded |= excludeLeftDataInterval(itValueData,depTrackPoint,exclusionType,false);
189 }
190 }
191
192 if (itValueData != valueData) {
193 if (!isDataValueExcluded(itValueData,exclusionType)) {
194 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
195 newValuesPotentiallyExcluded |= excludeDataValue(itValueData,depTrackPoint,exclusionType,false);
196 }
197
198 ++it;
199 if (it != itEnd) {
200 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
201 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
202
203 if (!isDataIntervalExcluded(itValueData,nextValueData,exclusionType)) {
204 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
205 newValuesPotentiallyExcluded |= excludeRightDataInterval(itValueData,depTrackPoint,exclusionType,false);
206 nextValueData = getDatatypeStringValueData(nextValueData->getValue(),nextMapData,true,nullptr);
207 newValuesPotentiallyExcluded |= excludeLeftDataInterval(nextValueData,depTrackPoint,exclusionType,false);
208 }
209 }
210 } else {
211 break;
212 }
213 }
214
215
216 return newValuesPotentiallyExcluded;
217 }
218
219
220
221 bool CDatatypeStringValueSpaceMap::excludeMaximum(CDataLiteralStringValue* value, bool valueInclusively, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType) {
222 bool newValuesPotentiallyExcluded = false;
223
224 CDatatypeStringValueData* valueData = getDatatypeStringValueData(value,true);
225 if (valueInclusively && !isDataValueExcluded(valueData,nullptr)) {
226 newValuesPotentiallyExcluded |= excludeDataValue(valueData,depTrackPoint,nullptr,false);
227 }
228
229 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
230 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
231 CDatatypeStringValueSpaceMap::iterator it = itLB;
232 while (it != itEnd) {
233 CDatatypeStringValueSpaceMapData& mapData = it.value();
234 CDatatypeStringValueData* itValueData = mapData.mUseValue;
235
236 if (itValueData != valueData) {
237 if (!isDataValueExcluded(itValueData,exclusionType)) {
238 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
239 newValuesPotentiallyExcluded |= excludeDataValue(itValueData,depTrackPoint,exclusionType,false);
240 }
241 }
242
243 ++it;
244 if (it != itEnd) {
245 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
246 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
247
248 if (!isDataIntervalExcluded(itValueData,nextValueData,exclusionType)) {
249 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
250 newValuesPotentiallyExcluded |= excludeRightDataInterval(itValueData,depTrackPoint,exclusionType,false);
251 nextValueData = getDatatypeStringValueData(nextValueData->getValue(),nextMapData,true,nullptr);
252 newValuesPotentiallyExcluded |= excludeLeftDataInterval(nextValueData,depTrackPoint,exclusionType,false);
253 }
254 } else {
255
256 if (!isRightDataIntervalExcluded(itValueData,exclusionType)) {
257 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
258 newValuesPotentiallyExcluded |= excludeLeftDataInterval(itValueData,depTrackPoint,exclusionType,false);
259 }
260 }
261 }
262
263 return newValuesPotentiallyExcluded;
264 }
265
266
267
268 bool CDatatypeStringValueSpaceMap::excludeAll(CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType) {
269 bool newValuesPotentiallyExcluded = false;
270
271 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itEnd = CDatatypeStringValueSpaceMap::end();
272 CDatatypeStringValueSpaceMap::iterator it = itBegin;
273
274 while (it != itEnd) {
275 CDatatypeStringValueSpaceMapData& mapData = it.value();
276 CDatatypeStringValueData* itValueData = mapData.mUseValue;
277
278 if (it == itBegin) {
279 if (!isLeftDataIntervalExcluded(itValueData,exclusionType)) {
280 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
281 newValuesPotentiallyExcluded |= excludeLeftDataInterval(itValueData,depTrackPoint,exclusionType,false);
282 }
283 if (!isDataValueExcluded(itValueData,exclusionType)) {
284 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
285 newValuesPotentiallyExcluded |= excludeDataValue(itValueData,depTrackPoint,exclusionType,false);
286 }
287 }
288
289 ++it;
290 if (it != itEnd) {
291 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
292 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
293
294 if (!isDataIntervalExcluded(itValueData,nextValueData,exclusionType)) {
295 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
296 newValuesPotentiallyExcluded |= excludeRightDataInterval(itValueData,depTrackPoint,exclusionType,false);
297 nextValueData = getDatatypeStringValueData(nextValueData->getValue(),nextMapData,true,nullptr);
298 newValuesPotentiallyExcluded |= excludeLeftDataInterval(nextValueData,depTrackPoint,exclusionType,false);
299 }
300 if (!isDataValueExcluded(nextValueData,exclusionType)) {
301 nextValueData = getDatatypeStringValueData(nextValueData->getValue(),nextMapData,true,nullptr);
302 newValuesPotentiallyExcluded |= excludeDataValue(nextValueData,depTrackPoint,exclusionType,false);
303 }
304
305
306 } else {
307 if (!isRightDataIntervalExcluded(itValueData,exclusionType)) {
308 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
309 newValuesPotentiallyExcluded |= excludeRightDataInterval(itValueData,depTrackPoint,exclusionType,false);
310 }
311 }
312
313 }
314
315 return newValuesPotentiallyExcluded;
316 }
317
318
319
320
321
322
323 bool CDatatypeStringValueSpaceMap::excludeInterval(CDataLiteralStringValue* leftValue, bool leftValueInclusive, CDataLiteralStringValue* rightValue, bool rightValueInclusive, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType) {
324 bool newValuesPotentiallyExcluded = false;
325
326 CDatatypeStringValueData* leftValueData = getDatatypeStringValueData(leftValue,true);
327 CDatatypeStringValueData* rightValueData = getDatatypeStringValueData(rightValue,true);
328
329 if (leftValueInclusive && !isDataValueExcluded(leftValueData,exclusionType)) {
330 newValuesPotentiallyExcluded |= excludeDataValue(leftValueData,depTrackPoint,exclusionType,false);
331 }
332
333 if (leftValueInclusive && !isDataValueExcluded(rightValueData,exclusionType)) {
334 newValuesPotentiallyExcluded |= excludeDataValue(rightValueData,depTrackPoint,exclusionType,false);
335 }
336
337
338 CDatatypeStringValueSpaceMapArranger mapValueArranger(leftValue);
339 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
340 CDatatypeStringValueSpaceMap::iterator it = itLB;
341 while (it != itEnd) {
342 CDatatypeStringValueSpaceMapData& mapData = it.value();
343 CDatatypeStringValueData* itValueData = mapData.mUseValue;
344
345 ++it;
346 if (it != itEnd) {
347 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
348 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
349
350 if (!isDataIntervalExcluded(itValueData,nextValueData,exclusionType)) {
351 itValueData = getDatatypeStringValueData(itValueData->getValue(),mapData,true,nullptr);
352 newValuesPotentiallyExcluded |= excludeRightDataInterval(itValueData,depTrackPoint,exclusionType,false);
353 nextValueData = getDatatypeStringValueData(nextValueData->getValue(),nextMapData,true,nullptr);
354 newValuesPotentiallyExcluded |= excludeLeftDataInterval(nextValueData,depTrackPoint,exclusionType,false);
355 }
356
357 if (nextValueData == rightValueData) {
358 break;
359 }
360
361 if (!isDataValueExcluded(nextValueData,exclusionType)) {
362 nextValueData = getDatatypeStringValueData(nextValueData->getValue(),nextMapData,true,nullptr);
363 newValuesPotentiallyExcluded |= excludeDataValue(nextValueData,depTrackPoint,exclusionType,false);
364 }
365 }
366 }
367
368 return newValuesPotentiallyExcluded;
369 }
370
371
372
373
374
375
376
377 bool CDatatypeStringValueSpaceMap::countDataIntervalValues(CDatatypeStringValueData* leftValueExcluded, CDatatypeStringValueData* rightValueExcluded, CDatatypeValueSpaceValuesCounter* counter) {
378 return countDataIntervalValues(leftValueExcluded->getValue(),rightValueExcluded->getValue(),leftValueExcluded->getRightExclusionData(),counter);
379 }
380
381 bool CDatatypeStringValueSpaceMap::countDataIntervalValues(CDataLiteralStringValue* leftValueExcluded, CDatatypeStringValueData* rightValueExcluded, CDatatypeValueSpaceValuesCounter* counter) {
382 return countDataIntervalValues(leftValueExcluded,rightValueExcluded->getValue(),rightValueExcluded->getLeftExclusionData(),counter);
383 }
384
385
386 bool CDatatypeStringValueSpaceMap::countDataIntervalValues(CDatatypeStringValueData* leftValueExcluded, CDataLiteralStringValue* rightValueExcluded, CDatatypeValueSpaceValuesCounter* counter) {
387 return countDataIntervalValues(leftValueExcluded->getValue(),rightValueExcluded,leftValueExcluded->getRightExclusionData(),counter);
388 }
389
390
391 bool CDatatypeStringValueSpaceMap::countDataIntervalValues(CDataLiteralStringValue* leftValueExcluded, CDataLiteralStringValue* rightValueExcluded, CDatatypeStringValueDataExclusion* exlcusionData, CDatatypeValueSpaceValuesCounter* counter) {
392 bool counted = false;
393 if (!exlcusionData->isEverythingExcluded()) {
394
395 counted |= counter->incInfinite();
396
397 CDatatypeValueSpaceStringValuesCounter* stringValuesCounter = dynamic_cast<CDatatypeValueSpaceStringValuesCounter*>(counter);
398 if (stringValuesCounter) {
399 if (!exlcusionData->areLanguageTagsExcluded()) {
400 counted |= stringValuesCounter->incInfinite(CDatatypeValueSpaceStringValuesCounter::SVT_WITH_LANGUAG_TAG_COUNT);
401 }
402 if (!exlcusionData->areOnlyLanguageTagsAllowed()) {
403 counted |= stringValuesCounter->incInfinite(CDatatypeValueSpaceStringValuesCounter::SVT_WITHOUT_LANGUAG_TAG_COUNT);
404 }
405 }
406 }
407 return counted;
408 }
409
410
411
412
413 bool CDatatypeStringValueSpaceMap::countDataValue(CDatatypeStringValueData* dataValue, CDatatypeValueSpaceValuesCounter* counter) {
414 return countDataValue(dataValue->getValue(),dataValue->getValueExclusionData(),counter);
415 }
416
417
418 bool CDatatypeStringValueSpaceMap::countDataValue(CDataLiteralStringValue* value, CDatatypeStringValueDataExclusion* exlcusionData, CDatatypeValueSpaceValuesCounter* counter) {
419 bool counted = false;
420 if (!exlcusionData->isEverythingExcluded()) {
421
422 if (value->isInfiniteLength()) {
423 counted |= counter->incInfinite();
424 } else {
425 counted |= counter->incValueCount(1);
426 }
427
428 CDatatypeValueSpaceStringValuesCounter* stringValuesCounter = dynamic_cast<CDatatypeValueSpaceStringValuesCounter*>(counter);
429 if (stringValuesCounter) {
430
431 if (value->isInfiniteLength()) {
432 if (!exlcusionData->areLanguageTagsExcluded()) {
433 counted |= stringValuesCounter->incInfinite(CDatatypeValueSpaceStringValuesCounter::SVT_WITH_LANGUAG_TAG_COUNT);
434 }
435 if (!exlcusionData->areOnlyLanguageTagsAllowed()) {
436 counted |= stringValuesCounter->incInfinite(CDatatypeValueSpaceStringValuesCounter::SVT_WITHOUT_LANGUAG_TAG_COUNT);
437 }
438 } else {
439 if (value->hasLanguageTag()) {
440 counted |= stringValuesCounter->incValueCount(CDatatypeValueSpaceStringValuesCounter::SVT_WITH_LANGUAG_TAG_COUNT,1);
441 } else {
442 counted |= stringValuesCounter->incValueCount(CDatatypeValueSpaceStringValuesCounter::SVT_WITHOUT_LANGUAG_TAG_COUNT,1);
443 }
444 }
445
446
447 }
448
449 }
450 return counted;
451 }
452
453
454
455
456 bool CDatatypeStringValueSpaceMap::countValueValues(CDataLiteralStringValue* value, CDatatypeValueSpaceValuesCounter* counter) {
457 bool counted = false;
458 if (mAbsoluteMinimumExclusionValue) {
459 if (value->isLessThan(mAbsoluteMinimumExclusionValue->getValue())) {
460 return false;
461 }
462 }
463 if (mAbsoluteMaximumExclusionValue) {
464 if (value->isGreaterThan(mAbsoluteMaximumExclusionValue->getValue())) {
465 return false;
466 }
467 }
468
469 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
470 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
471 CDatatypeStringValueSpaceMap::iterator it = itLB;
472
473
474 if (it != itEnd) {
475 CDatatypeStringValueSpaceMapData& mapData = it.value();
476 CDatatypeStringValueData* itValueData = mapData.mUseValue;
477
478 if (value->isEqualTo(itValueData->getValue())) {
479 if (!isDataValueExcluded(itValueData,nullptr)) {
480 counted |= countDataValue(itValueData,counter);
481 }
482 } else {
483 if (!isDataValueExcluded(value,nullptr)) {
484 counted |= countDataValue(value,itValueData->getLeftExclusionData(),counter);
485 }
486 }
487 }
488
489 return counted;
490 }
491
492
493
494
495
496
497
498 bool CDatatypeStringValueSpaceMap::addIntervalExclusionDependencies(CDataLiteralStringValue* leftValue, bool leftValueInclusive, CDataLiteralStringValue* rightValue, bool rightValueInclusive, CDatatypeValueSpaceDependencyCollector* depCollector) {
499 if (mAbsoluteMinimumExclusionValue) {
500 if (leftValue->isLessThan(mAbsoluteMinimumExclusionValue->getValue())) {
501 leftValue = mAbsoluteMinimumExclusionValue->getValue();
502 }
503 }
504 if (mAbsoluteMaximumExclusionValue) {
505 if (rightValue->isGreaterThan(mAbsoluteMaximumExclusionValue->getValue())) {
506 rightValue = mAbsoluteMaximumExclusionValue->getValue();
507 }
508 }
509
510 if (leftValue->isGreaterThan(rightValue)) {
511 return false;
512 } else if (leftValue->isEqualTo(rightValue)) {
513 if (!leftValueInclusive && !rightValueInclusive) {
514 return false;
515 }
516 }
517
518
519 bool depAdded = false;
520
521 CDatatypeStringValueSpaceMapArranger mapValueArranger(leftValue);
522 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
523 CDatatypeStringValueSpaceMap::iterator it = itLB;
524
525
526 while (it != itEnd) {
527 CDatatypeStringValueSpaceMapData& mapData = it.value();
528 CDatatypeStringValueData* itValueData = mapData.mUseValue;
529
530 if (it == itLB) {
531 if (leftValue->isEqualTo(itValueData->getValue())) {
532 if (leftValueInclusive) {
533 depAdded |= addDataValueExclusionDependencies(itValueData,depCollector);
534 }
535 } else {
536 depAdded |= addExclusionDependencies(itValueData->getLeftExclusionData(),depCollector);
537 }
538 }
539
540 ++it;
541 if (it != itEnd) {
542 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
543 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
544
545 depAdded |= addDataIntervalExclusionDependencies(itValueData,nextValueData,depCollector);
546
547 if (nextValueData->getValue()->isEqualTo(rightValue)) {
548 if (rightValueInclusive) {
549 depAdded |= addDataValueExclusionDependencies(nextValueData,depCollector);
550 }
551 break;
552 } else if (nextValueData->getValue()->isGreaterThan(rightValue)) {
553 depAdded |= addExclusionDependencies(itValueData->getRightExclusionData(),depCollector);
554 break;
555 }
556
557 depAdded |= addDataValueExclusionDependencies(nextValueData,depCollector);
558 }
559 }
560
561 return depAdded;
562
563 }
564
565
566
567
568
569 bool CDatatypeStringValueSpaceMap::addValueExclusionDependencies(CDataLiteralStringValue* value, CDatatypeValueSpaceDependencyCollector* depCollector) {
570 if (mAbsoluteMinimumExclusionValue) {
571 if (value->isLessThan(mAbsoluteMinimumExclusionValue->getValue())) {
572 return false;
573 }
574 }
575 if (mAbsoluteMaximumExclusionValue) {
576 if (value->isGreaterThan(mAbsoluteMaximumExclusionValue->getValue())) {
577 return false;
578 }
579 }
580
581
582 bool depAdded = false;
583
584 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
585 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
586 CDatatypeStringValueSpaceMap::iterator it = itLB;
587
588
589 if (it != itEnd) {
590 CDatatypeStringValueSpaceMapData& mapData = it.value();
591 CDatatypeStringValueData* itValueData = mapData.mUseValue;
592
593 if (value->isEqualTo(itValueData->getValue())) {
594 depAdded |= addDataValueExclusionDependencies(itValueData,depCollector);
595 } else if (value->isGreaterThan(itValueData->getValue())) {
596 depAdded |= addExclusionDependencies(itValueData->getRightExclusionData(),depCollector);
597 } else {
598 depAdded |= addExclusionDependencies(itValueData->getLeftExclusionData(),depCollector);
599 }
600 }
601
602 return depAdded;
603 }
604
605
606
607
608
609 bool CDatatypeStringValueSpaceMap::countAllValues(CDatatypeValueSpaceValuesCounter* counter) {
610 if (mAbsoluteMaximumExclusionValue && mAbsoluteMinimumExclusionValue) {
611 return countIntervalValues(mAbsoluteMinimumExclusionValue->getValue(),true,mAbsoluteMaximumExclusionValue->getValue(),true,counter);
612 }
613 return false;
614 }
615
616
617
618 bool CDatatypeStringValueSpaceMap::countIntervalValues(CDataLiteralStringValue* leftValue, bool leftValueInclusive, CDataLiteralStringValue* rightValue, bool rightValueInclusive, CDatatypeValueSpaceValuesCounter* counter) {
619 bool counted = false;
620
621 if (mAbsoluteMinimumExclusionValue) {
622 if (leftValue->isLessThan(mAbsoluteMinimumExclusionValue->getValue())) {
623 leftValue = mAbsoluteMinimumExclusionValue->getValue();
624 }
625 }
626 if (mAbsoluteMaximumExclusionValue) {
627 if (rightValue->isGreaterThan(mAbsoluteMaximumExclusionValue->getValue())) {
628 rightValue = mAbsoluteMaximumExclusionValue->getValue();
629 }
630 }
631
632 if (leftValue->isGreaterThan(rightValue)) {
633 return false;
634 } else if (leftValue->isEqualTo(rightValue)) {
635 if (!leftValueInclusive && !rightValueInclusive) {
636 return false;
637 }
638 }
639
640
641
642 CDatatypeStringValueSpaceMapArranger mapValueArranger(leftValue);
643 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
644 CDatatypeStringValueSpaceMap::iterator it = itLB;
645
646
647 while (it != itEnd) {
648 CDatatypeStringValueSpaceMapData& mapData = it.value();
649 CDatatypeStringValueData* itValueData = mapData.mUseValue;
650
651 if (it == itLB) {
652 if (leftValue->isEqualTo(itValueData->getValue())) {
653 if (leftValueInclusive) {
654 if (!isDataValueExcluded(itValueData,nullptr)) {
655 counted |= countDataValue(itValueData,counter);
656 }
657 }
658 } else {
659 if (leftValueInclusive) {
660 if (!isDataValueExcluded(leftValue,nullptr)) {
661 counted |= countDataValue(leftValue,itValueData->getLeftExclusionData(),counter);
662 }
663 }
664 if (!isDataIntervalExcluded(leftValue,itValueData,nullptr)) {
665 counted |= countDataIntervalValues(leftValue,itValueData,counter);
666 }
667 }
668 }
669
670 ++it;
671 if (it != itEnd) {
672 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
673 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
674
675 if (!isDataIntervalExcluded(itValueData,nextValueData,nullptr)) {
676 counted |= countDataIntervalValues(itValueData,nextValueData,counter);
677 }
678
679 if (nextValueData->getValue()->isEqualTo(rightValue)) {
680 if (rightValueInclusive) {
681 if (!isDataValueExcluded(nextValueData,nullptr)) {
682 counted |= countDataValue(nextValueData,counter);
683 }
684 }
685 break;
686 } else if (nextValueData->getValue()->isGreaterThan(rightValue)) {
687 if (rightValueInclusive) {
688 if (!isDataValueExcluded(rightValue,nullptr)) {
689 counted |= countDataValue(rightValue,nextValueData->getLeftExclusionData(),counter);
690 }
691 }
692 if (!isDataIntervalExcluded(nextValueData,rightValue,nullptr)) {
693 counted |= countDataIntervalValues(nextValueData,rightValue,counter);
694 }
695 break;
696 }
697
698 if (!isDataValueExcluded(nextValueData,nullptr)) {
699 counted |= countDataValue(nextValueData,counter);
700 }
701 }
702 }
703
704 return counted;
705 }
706
707
708
709
710
711
712
713
714
715
716
717 bool CDatatypeStringValueSpaceMap::excludeData(CDatatypeStringValueDataExclusion* exlcusionData, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType, bool force) {
718 if (!exclusionType) {
719 if (force || !exlcusionData->isExcluded()) {
720 exlcusionData->setExcluded(true);
721 exlcusionData->setExcludedDependencyTrackPoint(depTrackPoint);
722 return true;
723 }
724 } else {
725 if (force || !exlcusionData->isExcluded(exclusionType)) {
726 exlcusionData->setExclusion(exclusionType,depTrackPoint);
727 return true;
728 }
729 }
730 return false;
731 }
732
733
734 bool CDatatypeStringValueSpaceMap::excludeDataValue(CDatatypeStringValueData* dataValue, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType, bool force) {
735 return excludeData(dataValue->getValueExclusionData(),depTrackPoint,exclusionType,force);
736 }
737
738 bool CDatatypeStringValueSpaceMap::excludeLeftDataInterval(CDatatypeStringValueData* dataValue, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType, bool force) {
739 return excludeData(dataValue->getLeftExclusionData(),depTrackPoint,exclusionType,force);
740 }
741
742 bool CDatatypeStringValueSpaceMap::excludeRightDataInterval(CDatatypeStringValueData* dataValue, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType, bool force) {
743 return excludeData(dataValue->getRightExclusionData(),depTrackPoint,exclusionType,force);
744 }
745
746
747
748 bool CDatatypeStringValueSpaceMap::restrictToWithLanguageTagsValues(CDependencyTrackPoint* depTrackPoint) {
749 CDatatypeStringValueExclusionType exclusionType(CDatatypeStringValueExclusionType::SVET_LANGUAGE_TAGS_COMPLETELY,true);
750 return excludeAll(depTrackPoint,&exclusionType);
751 }
752
753
754 bool CDatatypeStringValueSpaceMap::restrictToWithoutLanguageTagsValues(CDependencyTrackPoint* depTrackPoint) {
755 CDatatypeStringValueExclusionType exclusionType(CDatatypeStringValueExclusionType::SVET_LANGUAGE_TAGS_COMPLETELY,false);
756 return excludeAll(depTrackPoint,&exclusionType);
757 }
758
759
760
761 bool CDatatypeStringValueSpaceMap::isRestrictedToWithLanguageTagsValues() {
762 CDatatypeStringValueExclusionType restictionType(CDatatypeStringValueExclusionType::SVET_LANGUAGE_TAGS_COMPLETELY, true);
763 return areAllValuesRestricted(&restictionType);
764 }
765
766 bool CDatatypeStringValueSpaceMap::isRestrictedToWithoutLanguageTagsValues() {
767 CDatatypeStringValueExclusionType restictionType(CDatatypeStringValueExclusionType::SVET_LANGUAGE_TAGS_COMPLETELY, false);
768 return areAllValuesRestricted(&restictionType);
769 }
770
771
772
773
774 bool CDatatypeStringValueSpaceMap::testValueSpaceReturnClashed() {
775
776 CDatatypeStringValueSpaceMap::const_iterator itBegin = CDatatypeStringValueSpaceMap::constBegin(), itEnd = CDatatypeStringValueSpaceMap::constEnd();
777 CDatatypeStringValueSpaceMap::const_iterator it = itBegin;
778
779 // test whether value space is empty
780 CDatatypeStringValueData* firstValueData = nullptr;
781
782 while (it != itEnd) {
783
784 const CDatatypeStringValueSpaceMapData& mapData = it.value();
785 CDatatypeStringValueData* itValueData = mapData.mUseValue;
786 if (!firstValueData) {
787 firstValueData = itValueData;
788 if (!isLeftDataIntervalExcluded(firstValueData,nullptr)) {
789 return false;
790 }
791 }
792 if (!isDataValueExcluded(itValueData,nullptr)) {
793 return false;
794 }
795 ++it;
796
797 if (it != itEnd) {
798 const CDatatypeStringValueSpaceMapData& nextMapData = it.value();
799 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
800 if (!isDataIntervalExcluded(itValueData,nextValueData,nullptr)) {
801 return false;
802 }
803 } else {
804 if (!isRightDataIntervalExcluded(itValueData,nullptr)) {
805 return false;
806 }
807 }
808 }
809 return true;
810 }
811
812
813
814
815 bool CDatatypeStringValueSpaceMap::addValueSpaceDependencies(CDatatypeValueSpaceDependencyCollector* depCollector) {
816
817 CDatatypeStringValueSpaceMap::const_iterator itBegin = CDatatypeStringValueSpaceMap::constBegin(), itEnd = CDatatypeStringValueSpaceMap::constEnd();
818 CDatatypeStringValueSpaceMap::const_iterator it = itBegin;
819
820 it = itBegin;
821 while (it != itEnd) {
822 const CDatatypeStringValueSpaceMapData& mapData = it.value();
823 CDatatypeStringValueData* itValueData = mapData.mUseValue;
824 addDataValueExclusionDependencies(itValueData,depCollector);
825
826 if (it == itBegin) {
827 addLeftIntervalExclusionDependencies(itValueData,depCollector);
828 }
829
830 ++it;
831 if (it == itEnd) {
832 addRightIntervalExclusionDependencies(itValueData,depCollector);
833 } else {
834 const CDatatypeStringValueSpaceMapData& nextMapData = it.value();
835 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
836
837 addDataIntervalExclusionDependencies(itValueData,nextValueData,depCollector);
838
839 }
840 }
841 return true;
842
843 }
844
845
846
847
848 bool CDatatypeStringValueSpaceMap::addValueSpaceDependencies(CDatatypeValueSpaceDependencyCollector* depCollector, CDatatypeStringValueExclusionType* exclusionType) {
849
850 CDatatypeStringValueSpaceMap::const_iterator itBegin = CDatatypeStringValueSpaceMap::constBegin(), itEnd = CDatatypeStringValueSpaceMap::constEnd();
851 CDatatypeStringValueSpaceMap::const_iterator it = itBegin;
852
853 it = itBegin;
854 while (it != itEnd) {
855 const CDatatypeStringValueSpaceMapData& mapData = it.value();
856 CDatatypeStringValueData* itValueData = mapData.mUseValue;
857 if (isDataValueExcluded(itValueData, exclusionType)) {
858 addDataValueExclusionDependencies(itValueData, depCollector);
859 }
860
861 if (it == itBegin) {
862 if (isLeftDataIntervalExcluded(itValueData, exclusionType)) {
863 addLeftIntervalExclusionDependencies(itValueData, depCollector);
864 }
865 }
866
867 ++it;
868 if (it == itEnd) {
869 if (isRightDataIntervalExcluded(itValueData, exclusionType)) {
870 addRightIntervalExclusionDependencies(itValueData, depCollector);
871 }
872 } else {
873 const CDatatypeStringValueSpaceMapData& nextMapData = it.value();
874 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
875
876 if (isDataIntervalExcluded(itValueData, nextValueData, exclusionType)) {
877 addDataIntervalExclusionDependencies(itValueData, nextValueData, depCollector);
878 }
879
880 }
881 }
882 return true;
883
884 }
885
886
887
888
889
890 bool CDatatypeStringValueSpaceMap::restrictToValue(CDataLiteralStringValue* value, CDependencyTrackPoint* depTrackPoint) {
891 bool newValuesPotentiallyExcluded = false;
892 newValuesPotentiallyExcluded |= excludeMinimum(value,false,depTrackPoint);
893 newValuesPotentiallyExcluded |= excludeMaximum(value,false,depTrackPoint);
894 return newValuesPotentiallyExcluded;
895 }
896
897
898
899 bool CDatatypeStringValueSpaceMap::excludeValue(CDataLiteralStringValue* value, CDependencyTrackPoint* depTrackPoint, CDatatypeStringValueExclusionType* exclusionType) {
900 bool newValuesPotentiallyExcluded = false;
901 if (mAbsoluteMinimumExclusionValue) {
902 if (mAbsoluteMinimumExclusionValue->getValue()->isGreaterThan(value)) {
903 return false;
904 }
905 if (mAbsoluteMinimumExclusionValue->getValue()->isEqualTo(value)) {
906 if (isDataValueExcluded(mAbsoluteMinimumExclusionValue,exclusionType)) {
907 return false;
908 }
909 }
910 }
911 if (mAbsoluteMaximumExclusionValue) {
912 if (mAbsoluteMaximumExclusionValue->getValue()->isGreaterThan(value)) {
913 return false;
914 }
915 if (mAbsoluteMaximumExclusionValue->getValue()->isEqualTo(value)) {
916 if (isDataValueExcluded(mAbsoluteMaximumExclusionValue,exclusionType)) {
917 return false;
918 }
919 }
920 }
921
922
923 CDatatypeStringValueData* valueData = getDatatypeStringValueData(value,true);
924 if (!isDataValueExcluded(valueData,exclusionType)) {
925 newValuesPotentiallyExcluded |= excludeDataValue(valueData,depTrackPoint,exclusionType,false);
926 }
927
928
929 return newValuesPotentiallyExcluded;
930 }
931
932
933
934
935
936
937
938 bool CDatatypeStringValueSpaceMap::addDataValueExclusionDependencies(CDatatypeStringValueData* dataValue, CDatatypeValueSpaceDependencyCollector* depCollector) {
939 CDatatypeStringValueDataExclusion* exclusionData = dataValue->getValueExclusionData();
940 return addExclusionDependencies(exclusionData,depCollector);
941 }
942
943 bool CDatatypeStringValueSpaceMap::addDataIntervalExclusionDependencies(CDatatypeStringValueData* leftValueExcluded, CDatatypeStringValueData* rightValueExcluded, CDatatypeValueSpaceDependencyCollector* depCollector) {
944 CDatatypeStringValueDataExclusion* exclusionData = leftValueExcluded->getRightExclusionData();
945 return addExclusionDependencies(exclusionData,depCollector);
946 }
947
948 bool CDatatypeStringValueSpaceMap::addLeftIntervalExclusionDependencies(CDatatypeStringValueData* valueData, CDatatypeValueSpaceDependencyCollector* depCollector) {
949 CDatatypeStringValueDataExclusion* exclusionData = valueData->getLeftExclusionData();
950 return addExclusionDependencies(exclusionData,depCollector);
951 }
952
953 bool CDatatypeStringValueSpaceMap::addRightIntervalExclusionDependencies(CDatatypeStringValueData* valueData, CDatatypeValueSpaceDependencyCollector* depCollector) {
954 CDatatypeStringValueDataExclusion* exclusionData = valueData->getRightExclusionData();
955 return addExclusionDependencies(exclusionData,depCollector);
956 }
957
958
959
960
961 bool CDatatypeStringValueSpaceMap::addExclusionDependencies(CDatatypeStringValueDataExclusion* exclusionData, CDatatypeValueSpaceDependencyCollector* depCollector) {
962 bool dependenciesAdded = false;
963 CDependencyTrackPoint* depTrackPoint = nullptr;
964 if (depCollector) {
965 if (exclusionData->isExcluded()) {
966 depTrackPoint = exclusionData->getExcludedDependencyTrackPoint();
967 if (depTrackPoint) {
968 dependenciesAdded |= depCollector->addDependency(depTrackPoint);
969 }
970 } else {
971 depTrackPoint = exclusionData->getPositiveExclusionDependencyTrackPoint();
972 if (depTrackPoint) {
973 dependenciesAdded |= depCollector->addDependency(depTrackPoint);
974 }
975 depTrackPoint = exclusionData->getNegativeExclusionDependencyTrackPoint();
976 if (depTrackPoint) {
977 dependenciesAdded |= depCollector->addDependency(depTrackPoint);
978 }
979 }
980 }
981 return dependenciesAdded;
982 }
983
984
985
986
987
988
989
990
991
992
993
994
995 bool CDatatypeStringValueSpaceMap::isLeftDataIntervalExcluded(CDatatypeStringValueData* dataValue, CDatatypeStringValueExclusionType* exclusionType) {
996 CDatatypeStringValueDataExclusion* exclusionData = dataValue->getLeftExclusionData();
997 if (exclusionData->isEverythingExcluded()) {
998 return true;
999 }
1000 if (exclusionType) {
1001 if (exclusionData->isExcluded(exclusionType)) {
1002 return true;
1003 }
1004 }
1005 return false;
1006 }
1007
1008
1009 bool CDatatypeStringValueSpaceMap::isRightDataIntervalExcluded(CDatatypeStringValueData* dataValue, CDatatypeStringValueExclusionType* exclusionType) {
1010 CDatatypeStringValueDataExclusion* exclusionData = dataValue->getRightExclusionData();
1011 if (exclusionData->isEverythingExcluded()) {
1012 return true;
1013 }
1014 if (exclusionType) {
1015 if (exclusionData->isExcluded(exclusionType)) {
1016 return true;
1017 }
1018 }
1019 return false;
1020 }
1021
1022
1023 bool CDatatypeStringValueSpaceMap::isDataIntervalExcluded(CDataLiteralStringValue* leftValueExcluded, CDatatypeStringValueData* rightValueExcluded, CDatatypeStringValueExclusionType* exclusionType) {
1024 CDatatypeStringValueDataExclusion* exclusionData = rightValueExcluded->getLeftExclusionData();
1025 if (exclusionData->isEverythingExcluded()) {
1026 return true;
1027 }
1028 if (exclusionType) {
1029 if (exclusionData->isExcluded(exclusionType)) {
1030 return true;
1031 }
1032 }
1033 return false;
1034 }
1035
1036
1037 bool CDatatypeStringValueSpaceMap::isDataIntervalExcluded(CDatatypeStringValueData* leftValueExcluded, CDataLiteralStringValue* rightValueExcluded, CDatatypeStringValueExclusionType* exclusionType) {
1038 CDatatypeStringValueDataExclusion* exclusionData = leftValueExcluded->getRightExclusionData();
1039 if (exclusionData->isEverythingExcluded()) {
1040 return true;
1041 }
1042 if (exclusionType) {
1043 if (exclusionData->isExcluded(exclusionType)) {
1044 return true;
1045 }
1046 }
1047 return false;
1048 }
1049
1050
1051 bool CDatatypeStringValueSpaceMap::isDataIntervalExcluded(CDatatypeStringValueData* leftValueExcluded, CDatatypeStringValueData* rightValueExcluded, CDatatypeStringValueExclusionType* exclusionType) {
1052 return isDataIntervalExcluded(leftValueExcluded,rightValueExcluded->getValue(),exclusionType);
1053 }
1054
1055
1056
1057
1058
1059 bool CDatatypeStringValueSpaceMap::isDataValueExcluded(CDatatypeStringValueData* valueData, CDatatypeStringValueExclusionType* exclusionType) {
1060 CDatatypeStringValueDataExclusion* exclusionData = valueData->getValueExclusionData();
1061 if (exclusionData->isEverythingExcluded()) {
1062 return true;
1063 }
1064 CDataLiteralStringValue* value = valueData->getValue();
1065 if (value->hasLanguageTag()) {
1066 if (exclusionData->areLanguageTagsExcluded()) {
1067 return true;
1068 }
1069 } else {
1070 if (exclusionData->areOnlyLanguageTagsAllowed()) {
1071 return true;
1072 }
1073 }
1074 if (exclusionType) {
1075 if (exclusionData->isExcluded(exclusionType)) {
1076 return true;
1077 }
1078 }
1079 return false;
1080 }
1081
1082
1083 bool CDatatypeStringValueSpaceMap::isDataValueExcluded(CDataLiteralStringValue* value, CDatatypeStringValueExclusionType* exclusionType) {
1084 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
1085 CDatatypeStringValueSpaceMap::const_iterator itBegin = CDatatypeStringValueSpaceMap::constBegin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::constEnd();
1086
1087 if (itBegin == itEnd) {
1088 return false;
1089 }
1090 if (itLB == itEnd) {
1091 return true;
1092 }
1093 const CDatatypeStringValueSpaceMapData& mapData = itLB.value();
1094 CDatatypeStringValueData* valueData = mapData.mUseValue;
1095 CDatatypeStringValueDataExclusion* exclusionData = nullptr;
1096 if (valueData->getValue()->isEqualTo(value)) {
1097 exclusionData = valueData->getValueExclusionData();
1098 } else if (valueData->getValue()->isLessThan(value)) {
1099 exclusionData = valueData->getLeftExclusionData();
1100 } else {
1101 exclusionData = valueData->getRightExclusionData();
1102 }
1103
1104 if (exclusionData) {
1105 CDatatypeStringValueDataExclusion* exclusionData = valueData->getValueExclusionData();
1106 if (exclusionData->isEverythingExcluded()) {
1107 return true;
1108 }
1109 CDataLiteralStringValue* value = valueData->getValue();
1110 if (value->hasLanguageTag()) {
1111 if (exclusionData->areLanguageTagsExcluded()) {
1112 return true;
1113 }
1114 } else {
1115 if (exclusionData->areOnlyLanguageTagsAllowed()) {
1116 return true;
1117 }
1118 }
1119
1120 }
1121 if (exclusionType) {
1122 if (exclusionData->isExcluded(exclusionType)) {
1123 return true;
1124 }
1125 }
1126 return false;
1127 }
1128
1129
1130
1131 bool CDatatypeStringValueSpaceMap::adaptNewStringValueDataToNeighbours(CDatatypeStringValueData* valueData) {
1132 CDatatypeStringValueSpaceMapArranger mapValueArranger(valueData->getValue());
1133 CDatatypeStringValueSpaceMap::const_iterator itBegin = CDatatypeStringValueSpaceMap::constBegin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::constEnd();
1134 CDatatypeStringValueSpaceMap::const_iterator itAdapt = itLB;
1135 bool rightNeighbour = true;
1136 ++itAdapt;
1137 if (itAdapt == itEnd) {
1138 itAdapt = itLB;
1139 --itAdapt;
1140 rightNeighbour = false;
1141 }
1142 if (itAdapt != itEnd) {
1143 const CDatatypeStringValueSpaceMapData& adaptMapData = itAdapt.value();
1144 CDatatypeStringValueData* adaptValueData = adaptMapData.mUseValue;
1145 CDatatypeStringValueDataExclusion* exclusionData = nullptr;
1146 if (rightNeighbour) {
1147 exclusionData = adaptValueData->getLeftExclusionData();
1148 } else {
1149 exclusionData = adaptValueData->getRightExclusionData();
1150 }
1151 valueData->getValueExclusionData()->initDataExclusion(exclusionData);
1152 valueData->getLeftExclusionData()->initDataExclusion(exclusionData);
1153 valueData->getRightExclusionData()->initDataExclusion(exclusionData);
1154 return true;
1155 }
1156 return false;
1157 }
1158
1159
1160 CDatatypeStringValueData* CDatatypeStringValueSpaceMap::getDatatypeStringValueData(CDataLiteralStringValue* value, CDatatypeStringValueSpaceMapData& valueMapData, bool createOrLocalize, bool* newValueInsertion) {
1161 if (newValueInsertion) {
1162 *newValueInsertion = false;
1163 }
1164 CDatatypeStringValueData* stringValueData = nullptr;
1165 if (!valueMapData.mLocValue) {
1166 bool newlyCreated = false;
1167 CMemoryAllocationManager* taskMemMan = mProcessContext->getUsedMemoryAllocationManager();
1168 stringValueData = CObjectParameterizingAllocator< CDatatypeStringValueData,CProcessContext* >::allocateAndConstructAndParameterize(taskMemMan,mProcessContext);
1169 stringValueData->initStringValueData(valueMapData.mUseValue,value);
1170 if (!valueMapData.mUseValue) {
1171 newlyCreated = true;
1172 }
1173 valueMapData.mUseValue = valueMapData.mLocValue = stringValueData;
1174 if (newlyCreated) {
1175 adaptNewStringValueDataToNeighbours(stringValueData);
1176 }
1177 if (newlyCreated && newValueInsertion) {
1178 *newValueInsertion = true;
1179 }
1180 } else {
1181 stringValueData = valueMapData.mUseValue;
1182 }
1183 return stringValueData;
1184 }
1185
1186
1187
1188 CDatatypeStringValueData* CDatatypeStringValueSpaceMap::getDatatypeStringValueData(CDataLiteralStringValue* value, bool createOrLocalize, bool* newValueInsertion) {
1189 if (newValueInsertion) {
1190 *newValueInsertion = false;
1191 }
1192 CDatatypeStringValueData* stringValueData = nullptr;
1193 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
1194 if (createOrLocalize) {
1195 CDatatypeStringValueSpaceMapData& data = CPROCESSMAP<CDatatypeStringValueSpaceMapArranger,CDatatypeStringValueSpaceMapData>::operator[](mapValueArranger);
1196 stringValueData = getDatatypeStringValueData(value,data,createOrLocalize,newValueInsertion);
1197 } else {
1198 CDatatypeStringValueSpaceMapData data = CPROCESSMAP<CDatatypeStringValueSpaceMapArranger,CDatatypeStringValueSpaceMapData>::value(mapValueArranger);
1199 stringValueData = data.mUseValue;
1200 }
1201 return stringValueData;
1202 }
1203
1204
1205
1206
1207 bool CDatatypeStringValueSpaceMap::areAllValuesRestricted(CDatatypeStringValueExclusionType* exclusionType) {
1208 CDatatypeStringValueSpaceMap::const_iterator itBegin = CDatatypeStringValueSpaceMap::constBegin(), itEnd = CDatatypeStringValueSpaceMap::constEnd();
1209 CDatatypeStringValueSpaceMap::const_iterator it = itBegin;
1210 if (it == itEnd) {
1211 return true;
1212 }
1213 while (it != itEnd) {
1214 const CDatatypeStringValueSpaceMapData& mapData = it.value();
1215 CDatatypeStringValueData* stringValueData = mapData.mUseValue;
1216 if (!isDataValueExcluded(stringValueData,exclusionType)) {
1217 return false;
1218 }
1219
1220 if (it == itBegin) {
1221 if (!isLeftDataIntervalExcluded(stringValueData, exclusionType)) {
1222 return false;
1223 }
1224 }
1225 ++it;
1226
1227 if (it == itEnd) {
1228 if (!isRightDataIntervalExcluded(stringValueData, exclusionType)) {
1229 return false;
1230 }
1231 } else {
1232 const CDatatypeStringValueSpaceMapData& nextMapData = it.value();
1233 CDatatypeStringValueData* nextStringValueData = nextMapData.mUseValue;
1234 if (!isDataIntervalExcluded(stringValueData, nextStringValueData, exclusionType)) {
1235 return false;
1236 }
1237 }
1238 }
1239 return true;
1240 }
1241
1242
1243 bool CDatatypeStringValueSpaceMap::hasExcludedMinimum(CDataLiteralStringValue* value, bool valueInclusively, CDatatypeStringValueExclusionType* exclusionType) {
1244
1245 if (mAbsoluteMinimumExclusionValue) {
1246 if (mAbsoluteMinimumExclusionValue->getValue()->isGreaterThan(value)) {
1247 return true;
1248 }
1249 if (mAbsoluteMinimumExclusionValue->getValue()->isEqualTo(value)) {
1250 if (isDataValueExcluded(mAbsoluteMinimumExclusionValue,exclusionType)) {
1251 return true;
1252 }
1253 if (!valueInclusively) {
1254 return true;
1255 }
1256 }
1257 }
1258
1259 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
1260 CDatatypeStringValueSpaceMap::const_iterator itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), it = CDatatypeStringValueSpaceMap::constBegin(), itEnd = CDatatypeStringValueSpaceMap::constEnd();
1261 if (it == itEnd) {
1262 // no restrictions in value map
1263 return false;
1264 }
1265 if (it == itLB) {
1266 const CDatatypeStringValueSpaceMapData& mapData = it.value();
1267 CDatatypeStringValueData* stringValueData = mapData.mUseValue;
1268 if (!valueInclusively) {
1269 // value is before first value --> excluded
1270 return isLeftDataIntervalExcluded(stringValueData,exclusionType);
1271 } else {
1272 if (!isDataValueExcluded(stringValueData,exclusionType)) {
1273 return false;
1274 }
1275 return true;
1276 }
1277 }
1278 if (itLB == itEnd) {
1279 // value is after last value --> not excluded assuming value space is not clashed
1280 return false;
1281 }
1282 while (it != itEnd && it != itLB) {
1283 // try to find valid values before tested minimum value limit
1284 const CDatatypeStringValueSpaceMapData& mapData = it.value();
1285 CDatatypeStringValueData* stringValueData = mapData.mUseValue;
1286 if (!isDataValueExcluded(stringValueData,exclusionType)) {
1287 return false;
1288 }
1289 ++it;
1290
1291 if (it != itEnd) {
1292 const CDatatypeStringValueSpaceMapData& nextMapData = it.value();
1293 CDatatypeStringValueData* nextStringValueData = nextMapData.mUseValue;
1294 if (it != itLB) {
1295 if (!isDataIntervalExcluded(stringValueData,nextStringValueData,exclusionType)) {
1296 return false;
1297 }
1298 } else {
1299 if (nextStringValueData->getValue()->isEqualTo(value)) {
1300 // value is in the value space map
1301 if (!isDataIntervalExcluded(stringValueData,nextStringValueData,exclusionType)) {
1302 return false;
1303 }
1304 if (valueInclusively && !isDataValueExcluded(nextStringValueData,exclusionType)) {
1305 return false;
1306 }
1307 } else {
1308 // test only to the tested minimum value limit
1309 if (!isDataIntervalExcluded(stringValueData,value,exclusionType)) {
1310 return false;
1311 }
1312 if (valueInclusively && !isDataValueExcluded(value,exclusionType)) {
1313 return false;
1314 }
1315 }
1316 }
1317 }
1318 }
1319 return true;
1320 }
1321
1322
1323
1324 bool CDatatypeStringValueSpaceMap::hasExcludedMaximum(CDataLiteralStringValue* value, bool valueInclusively, CDatatypeStringValueExclusionType* exclusionType) {
1325
1326 if (mAbsoluteMaximumExclusionValue) {
1327 if (mAbsoluteMaximumExclusionValue->getValue()->isLessThan(value)) {
1328 return true;
1329 }
1330 if (mAbsoluteMaximumExclusionValue->getValue()->isEqualTo(value)) {
1331 if (isDataValueExcluded(mAbsoluteMaximumExclusionValue,exclusionType)) {
1332 return true;
1333 }
1334 if (!valueInclusively) {
1335 return true;
1336 }
1337 }
1338 }
1339
1340 CDatatypeStringValueSpaceMapArranger mapValueArranger(value);
1341 CDatatypeStringValueSpaceMap::const_iterator itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), it = CDatatypeStringValueSpaceMap::constBegin(), itEnd = CDatatypeStringValueSpaceMap::constEnd();
1342 if (it == itEnd) {
1343 // no restrictions in value map
1344 return false;
1345 }
1346 if (itLB == itEnd) {
1347 // value is after last value --> excluded
1348 return true;
1349 }
1350 it = itLB;
1351 while (it != itEnd) {
1352 const CDatatypeStringValueSpaceMapData& mapData = it.value();
1353 CDatatypeStringValueData* stringValueData = mapData.mUseValue;
1354 if (it == itLB) {
1355 if (stringValueData->getValue()->isEqualTo(value)) {
1356 if (valueInclusively && !isDataValueExcluded(stringValueData,exclusionType)) {
1357 return false;
1358 }
1359 } else {
1360 if (!isDataIntervalExcluded(value,stringValueData,exclusionType)) {
1361 return false;
1362 }
1363 if (!isDataValueExcluded(stringValueData,exclusionType)) {
1364 return false;
1365 }
1366 if (valueInclusively && !isDataValueExcluded(value,exclusionType)) {
1367 return false;
1368 }
1369 }
1370 }
1371 ++it;
1372 if (it != itEnd) {
1373 const CDatatypeStringValueSpaceMapData& nextMapData = it.value();
1374 CDatatypeStringValueData* nextStringValueData = nextMapData.mUseValue;
1375
1376 if (!isDataValueExcluded(nextStringValueData,exclusionType)) {
1377 return false;
1378 }
1379 if (!isDataIntervalExcluded(stringValueData,nextStringValueData,exclusionType)) {
1380 return false;
1381 }
1382 } else {
1383 if (!isRightDataIntervalExcluded(stringValueData,exclusionType)) {
1384 return false;
1385 }
1386 }
1387 }
1388 return true;
1389 }
1390
1391
1392 bool CDatatypeStringValueSpaceMap::isValueExcluded(CDataLiteralStringValue* value, CDatatypeStringValueExclusionType* exclusionType) {
1393 if (isDataValueExcluded(value,exclusionType)) {
1394 return true;
1395 }
1396 return false;
1397 }
1398
1399
1400
1401 bool CDatatypeStringValueSpaceMap::getNextPossibleDataValue(CDataLiteralStringValue* nextValue, CDataLiteralStringValue* lastValue) {
1402
1403 if (!lastValue) {
1404 if (!mAbsoluteMinimumExclusionValue) {
1405 return false;
1406 }
1407 lastValue = mAbsoluteMinimumExclusionValue->getValue();
1408 if (!isDataValueExcluded(mAbsoluteMinimumExclusionValue,nullptr)) {
1409 nextValue->initValue(lastValue);
1410 return true;
1411 }
1412 }
1413
1414
1415 CDatatypeStringValueSpaceMapArranger mapValueArranger(lastValue);
1416 CDatatypeStringValueSpaceMap::iterator itBegin = CDatatypeStringValueSpaceMap::begin(), itLB = CDatatypeStringValueSpaceMap::lowerBound(mapValueArranger), itEnd = CDatatypeStringValueSpaceMap::end();
1417 CDatatypeStringValueSpaceMap::iterator it = itLB;
1418 while (it != itEnd) {
1419
1420 if (it == itLB) {
1421 CDatatypeStringValueData* itValueData = it.value().mUseValue;
1422 while (lastValue->isLessThan(itValueData->getValue())) {
1423 CDatatypeStringValueSpaceMap::iterator itLast = it;
1424 --itLast;
1425 if (itLast != itEnd) {
1426 --it;
1427 } else {
1428 if (!isLeftDataIntervalExcluded(itValueData,nullptr)) {
1429 return false;
1430 }
1431 break;
1432 }
1433 }
1434 }
1435 CDatatypeStringValueSpaceMapData& mapData = it.value();
1436 CDatatypeStringValueData* itValueData = mapData.mUseValue;
1437
1438 if (itValueData->getValue()->isGreaterThan(lastValue)) {
1439 lastValue = itValueData->getValue();
1440 }
1441
1442 ++it;
1443 if (it != itEnd) {
1444 CDatatypeStringValueSpaceMapData& nextMapData = it.value();
1445 CDatatypeStringValueData* nextValueData = nextMapData.mUseValue;
1446
1447 if (!isDataIntervalExcluded(itValueData,nextValueData,nullptr)) {
1448 return false;
1449
1450 } else if (!isDataValueExcluded(nextValueData,nullptr)) {
1451 nextValue->initValue(nextValueData->getValue());
1452 return true;
1453 }
1454 } else {
1455 return false;
1456 }
1457
1458 }
1459 return false;
1460 }
1461
1462
1463
1464 }; // end namespace Process
1465
1466 }; // end namespace Kernel
1467
1468 }; // end namespace Reasoner
1469
1470 }; // end namespace Konclude