Debian Codegraph @

Source/Utilities/Container/CModelDataLevelArray.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 "CModelDataLevelArray.h"
22
23
24 namespace Konclude {
25
26 namespace Utilities {
27
28 namespace Container {
29
30 CModelDataLevelArray::CModelDataLevelArray() : CModelDataArray() {
31 for (qint64 i = 0; i < dataSize; ++i) {
32 modelArray[i] = 0;
33 }
34 level = 0;
35 }
36
37
38 CModelDataLevelArray::CModelDataLevelArray(qint64 tagBegin, qint64 tagBegEndSize) : CModelDataArray(tagBegin,tagBegEndSize) {
39 for (qint64 i = 0; i < dataSize; ++i) {
40 modelArray[i] = 0;
41 }
42 }
43
44
45 CModelDataLevelArray::~CModelDataLevelArray() {
46 }
47
48
49 CModelDataArray *CModelDataLevelArray::init(qint64 tagBegin, qint64 tagBegEndSize) {
50 CModelDataArray::init(tagBegin,tagBegEndSize);
51 for (qint64 i = 0; i < dataSize; ++i) {
52 modelArray[i] = 0;
53 }
54 return this;
55 }
56
57 bool CModelDataLevelArray::isBaseLevel() {
58 return tagSize == dataSize;
59 }
60
61 qint64 CModelDataLevelArray::getModelLevel() {
62 return level;
63 }
64
65 CModelDataLevelArray *CModelDataLevelArray::setBounds(qint64 tagBegin, qint64 tagBegEndSize) {
66 CModelDataArray::setBounds(tagBegin,tagBegEndSize);
67 level = bitIndShift / log2DataSize;
68 return this;
69 }
70
71 CModelDataArray **CModelDataLevelArray::getModelArray() {
72 return modelArray;
73 }
74
75
76 CModelDataArray *CModelDataLevelArray::getNextModelArray(qint64 index) {
77 return modelArray[index];
78 }
79
80 CModelDataArray *CModelDataLevelArray::getBaseModel(qint64 beginTag) {
81 CModelDataArray *modelData = getNextModelArray(getArrayIndex(beginTag));
82 if (modelData) {
83 return modelData->getBaseModel(beginTag);
84 } else {
85 return 0;
86 }
87 }
88
89 qint64 CModelDataLevelArray::getFirstFlagTag() {
90 for (qint64 mask = 0x1, idx = 0; idx < dataSize; mask<<=1,++idx) {
91 if ((mask & dataArray) != 0) {
92 CModelDataArray *model = modelArray[idx];
93 return model->getFirstFlagTag();
94 }
95 }
96 return endTag;
97 }
98
99 qint64 CModelDataLevelArray::getLastFlagTag() {
100 for (qint64 mask = Q_INT64_C(0x8000000000000000), idx = dataSize-1; idx >= 0; mask>>=1,--idx) {
101 if ((mask & dataArray) != 0) {
102 CModelDataArray *model = modelArray[idx];
103 return model->getLastFlagTag();
104 }
105 }
106 return begTag;
107 }
108
109
110 CModelDataArray *CModelDataLevelArray::setNextModelArray(qint64 index, CModelDataArray *nextModelDataArray) {
111 modelArray[index] = nextModelDataArray;
112 if (nextModelDataArray && nextModelDataArray->getDataArray() != 0) {
113 setLevelFlagIndex(index,true);
114 } else {
115 setLevelFlagIndex(index,false);
116 }
117 return this;
118 }
119
120
121 CModelDataLevelArray *CModelDataLevelArray::setData(bool value) {
122 CModelDataArray::setData(value);
123 for (qint64 i = 0; i < dataSize; ++i) {
124 CModelDataArray *modelData = modelArray[i];
125 if (modelData) {
126 modelData->setData(value);
127 }
128 }
129 return this;
130 }
131
132
133 CModelDataArray *CModelDataLevelArray::createNextModelArray(qint64 index, CDataArrayMemoryManager *modelMemMan) {
134 CModelDataArray *modelData = modelArray[index];
135 if (!modelData && modelMemMan) {
136 if (level <= 1) {
137 modelData = modelMemMan->allocateModelDataArray();
138 } else {
139 modelData = modelMemMan->allocateModelDataLevelArray();
140 }
141 qint64 nextTagSize = tagSize/dataSize;
142 qint64 nextBegTag = begTag + index*nextTagSize;
143 modelData->init(nextBegTag,nextTagSize);
144 modelArray[index] = modelData;
145 }
146 return modelData;
147 }
148
149
150 bool CModelDataLevelArray::setFlag(qint64 tag, bool flag, CDataArrayMemoryManager *modelMemMan) {
151 if (flag) {
152 CModelDataArray::setFlag(tag,flag);
153 }
154 if (begTag >= tag && tag < endTag) {
155 qint64 index = (tag-begTag) >> bitIndShift;
156 qint64 arrayIndex = index & bitIndMask;
157 CModelDataArray *modelData = createNextModelArray(arrayIndex,modelMemMan);
158 if (modelData->setFlag(tag,flag)) {
159 if (modelData->getDataArray() == 0) {
160 CModelDataArray::setLevelFlagIndex(arrayIndex,false);
161 }
162 return true;
163 }
164 }
165 return false;
166 }
167
168
169 bool CModelDataLevelArray::setFlag(qint64 tag, bool flag) {
170 if (begTag >= tag && tag < endTag) {
171 if (flag) {
172 CModelDataArray::setFlag(tag,flag);
173 }
174 qint64 index = (tag-begTag) >> bitIndShift;
175 qint64 arrayIndex = index & bitIndMask;
176 CModelDataArray *modelData = modelArray[arrayIndex];
177 if (modelData) {
178 if (modelData->setFlag(tag,flag)) {
179 if (modelData->getDataArray() == 0) {
180 CModelDataArray::setFlag(tag,false);
181 }
182 return true;
183 }
184 }
185 }
186 return false;
187 }
188
189 bool CModelDataLevelArray::getFlag(qint64 tag) {
190 if (begTag >= tag && tag < endTag) {
191 qint64 index = (tag-begTag) >> bitIndShift;
192 qint64 arrayIndex = index & bitIndMask;
193 CModelDataArray *modelData = modelArray[arrayIndex];
194 if (modelData) {
195 return modelData->getFlag(tag);
196 }
197 }
198 return 0;
199 }
200
201
202 qint64 CModelDataLevelArray::getArrayIndex(qint64 tag) {
203 qint64 index = (tag-begTag) >> bitIndShift;
204 qint64 arrayIndex = index & bitIndMask;
205 return arrayIndex;
206 }
207
208
209 CModelDataArray *CModelDataLevelArray::intersectWith(CModelDataArray *modelData, bool *flagModification) {
210 return intersectWith(modelData,0,flagModification);
211 }
212
213
214 CModelDataArray *CModelDataLevelArray::unionWith(CModelDataArray *modelData, bool *flagModification) {
215 return unionWith(modelData,0,flagModification);
216 }
217
218
219
220 bool CModelDataLevelArray::testHasIntersectBetween(CModelDataArray *modelData1, CModelDataArray *modelData2) {
221 if (!modelData1 || !modelData2) {
222 return false;
223 } else {
224 CModelDataLevelArray *modelDataLevel = dynamic_cast<CModelDataLevelArray *>(modelData1);
225 if (modelDataLevel) {
226 modelData1->hasIntersectionWith(modelData2);
227 }
228 return modelData2->hasIntersectionWith(modelData1);
229 }
230 }
231
232
233 bool CModelDataLevelArray::testIsSubsetBetween(CModelDataArray *modelData1, CModelDataArray *modelData2) {
234 if (!modelData1) {
235 return true;
236 } else if (!modelData2) {
237 return false;
238 } else {
239 CModelDataLevelArray *modelDataLevel = dynamic_cast<CModelDataLevelArray *>(modelData1);
240 if (modelDataLevel) {
241 return modelData1->isSubsetFrom(modelData2);
242 } else {
243 return modelData2->isSuperSetTo(modelData1);
244 }
245 }
246 }
247
248
249 bool CModelDataLevelArray::isSubsetFrom(CModelDataArray *modelData) {
250 if (dataArray == 0) {
251 return true;
252 }
253 if (modelData) {
254 qint64 modelDataArray = modelData->getDataArray();
255 if (modelDataArray == 0 && dataArray != 0) {
256 return false;
257 }
258 qint64 modelDataBegTag = modelData->getBeginTag();
259 qint64 modelDataEndTag = modelData->getEndTag();
260 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
261 qint64 modelDataTagSize = modelData->getTagSize();
262 if (tagSize == modelDataTagSize) {
263 // modelData has the same interval as this
264 qint64 dataArrayIntersection = dataArray & modelDataArray;
265 if (dataArrayIntersection != dataArray) {
266 return false;
267 } else {
268 // test possible subset
269 if (isBaseLevel()) {
270 return true;
271 } else {
272 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
273 for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) {
274 if ((dataArrayIntersection & mask) != 0) {
275 CModelDataArray *nextLevelModel = modelArray[i];
276 if (!nextLevelModel->isSubsetFrom(modelDataLevelArray->getNextModelArray(i))) {
277 return false;
278 }
279 }
280 }
281 return true;
282 }
283 }
284 } else {
285 // modelData has a smaller interval than this
286 if (modelDataArray != 0 && getLevelFlag(modelDataBegTag)) {
287 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
288 if ((1<<arrayIndex) != dataArray) {
289 return false;
290 } else {
291 // test modelData subset with next level
292 CModelDataArray *nextLevelModel = modelArray[arrayIndex];
293 return nextLevelModel->isSubsetFrom(modelData);
294 }
295 }
296 }
297 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
298 // modelData has a larger interval than this
299 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
300 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
301 return isSubsetFrom(modelDataLevelArray->getNextModelArray(arrayIndex));
302 }
303 }
304 return false;
305 }
306
307
308 bool CModelDataLevelArray::isSuperSetTo(CModelDataArray *modelData) {
309 if (modelData == 0) {
310 return true;
311 }
312 if (modelData) {
313 qint64 modelDataArray = modelData->getDataArray();
314 if (modelDataArray != 0 && dataArray == 0) {
315 return false;
316 }
317 qint64 modelDataBegTag = modelData->getBeginTag();
318 qint64 modelDataEndTag = modelData->getEndTag();
319 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
320 qint64 modelDataTagSize = modelData->getTagSize();
321 if (tagSize == modelDataTagSize) {
322 // modelData has the same interval as this
323 qint64 dataArrayIntersection = dataArray & modelDataArray;
324 if (dataArrayIntersection != modelDataArray) {
325 return false;
326 } else {
327 // test possible subset
328 if (isBaseLevel()) {
329 return true;
330 } else {
331 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
332 for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) {
333 if ((dataArrayIntersection & mask) != 0) {
334 CModelDataArray *nextLevelModel = modelArray[i];
335 if (!nextLevelModel->isSuperSetTo(modelDataLevelArray->getNextModelArray(i))) {
336 return false;
337 }
338 }
339 }
340 return true;
341 }
342 }
343 } else {
344 // modelData has a smaller interval than this
345 if (getLevelFlag(modelDataBegTag)) {
346 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
347 // test modelData subset with next level
348 CModelDataArray *nextLevelModel = modelArray[arrayIndex];
349 return nextLevelModel->isSuperSetTo(modelData);
350 }
351 }
352 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
353 // modelData has a larger interval than this
354 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
355 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
356 if ((1<<arrayIndex) != modelDataArray) {
357 return false;
358 } else {
359 return isSuperSetTo(modelDataLevelArray->getNextModelArray(arrayIndex));
360 }
361 }
362 }
363 return false;
364 }
365
366 bool CModelDataLevelArray::hasIntersectionWith(CModelDataArray *modelData) {
367 if (modelData) {
368 qint64 modelDataBegTag = modelData->getBeginTag();
369 qint64 modelDataEndTag = modelData->getEndTag();
370 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
371 qint64 modelDataTagSize = modelData->getTagSize();
372 if (tagSize == modelDataTagSize) {
373 // modelData has the same interval as this
374 qint64 modelDataArray = modelData->getDataArray();
375 qint64 dataArrayIntersection = dataArray & modelDataArray;
376 if (dataArrayIntersection != 0) {
377 // test possible intersections
378 if (isBaseLevel()) {
379 return true;
380 } else {
381 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
382 for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) {
383 if ((dataArrayIntersection & mask) != 0) {
384 CModelDataArray *nextLevelModel = modelArray[i];
385 if (nextLevelModel && nextLevelModel->hasIntersectionWith(modelDataLevelArray->getNextModelArray(i))) {
386 return true;
387 }
388 }
389 }
390 }
391 }
392 } else {
393 // modelData has a smaller interval than this
394 qint64 modelDataArray = modelData->getDataArray();
395 if (modelDataArray != 0 && getLevelFlag(modelDataBegTag)) {
396 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
397 // test modelData intersection with next level
398 CModelDataArray *nextLevelModel = modelArray[arrayIndex];
399 if (nextLevelModel && nextLevelModel->hasIntersectionWith(modelData)) {
400 return true;
401 }
402 }
403 }
404 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
405 // modelData has a larger interval than this
406 if (dataArray != 0) {
407 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
408 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
409 if (hasIntersectionWith(modelDataLevelArray->getNextModelArray(arrayIndex))) {
410 return true;
411 }
412 }
413 }
414 }
415 return false;
416 }
417
418
419
420
421 qint64 CModelDataLevelArray::countIntersectionWith(CModelDataArray *modelData) {
422 qint64 inCount = 0;
423 if (modelData) {
424 qint64 modelDataBegTag = modelData->getBeginTag();
425 qint64 modelDataEndTag = modelData->getEndTag();
426 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
427 qint64 modelDataTagSize = modelData->getTagSize();
428 if (tagSize == modelDataTagSize) {
429 // modelData has the same interval as this
430 qint64 modelDataArray = modelData->getDataArray();
431 qint64 dataArrayIntersection = dataArray & modelDataArray;
432 if (dataArrayIntersection != 0) {
433 // test possible intersections
434 if (isBaseLevel()) {
435 inCount = CModelDataArray::countIntersectionWith(modelData);
436 } else {
437 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
438 for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) {
439 if ((dataArrayIntersection & mask) != 0) {
440 CModelDataArray *nextLevelModel = modelArray[i];
441 if (nextLevelModel) {
442 inCount += nextLevelModel->countIntersectionWith(modelDataLevelArray->getNextModelArray(i));
443 }
444 }
445 }
446 }
447 }
448 } else {
449 // modelData has a smaller interval than this
450 qint64 modelDataArray = modelData->getDataArray();
451 if (modelDataArray != 0 && getLevelFlag(modelDataBegTag)) {
452 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
453 // test modelData intersection with next level
454 CModelDataArray *nextLevelModel = modelArray[arrayIndex];
455 if (nextLevelModel) {
456 inCount += nextLevelModel->countIntersectionWith(modelData);
457 }
458 }
459 }
460 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
461 // modelData has a larger interval than this
462 if (dataArray != 0) {
463 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
464 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
465 inCount += countIntersectionWith(modelDataLevelArray->getNextModelArray(arrayIndex));
466 }
467 }
468 }
469 return inCount;
470 }
471
472
473 qint64 CModelDataLevelArray::countFlags() {
474 qint64 count = 0;
475 if (!isBaseLevel()) {
476 for (qint64 i = 0, mask = 0x1; i < 64; ++i,mask <<= 1) {
477 if ((dataArray & mask) != 0) {
478 CModelDataArray *modelArray = getNextModelArray(i);
479 if (modelArray) {
480 count += modelArray->countFlags();
481 }
482 }
483 }
484 } else {
485 count = CModelDataArray::countFlags();
486 }
487 return count;
488 }
489
490
491
492 CModelDataArray *CModelDataLevelArray::intersectWith(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
493 if (modelData) {
494 qint64 modelDataBegTag = modelData->getBeginTag();
495 qint64 modelDataEndTag = modelData->getEndTag();
496 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
497 qint64 modelDataTagSize = modelData->getTagSize();
498 if (tagSize == modelDataTagSize) {
499 // modelData has the same interval as this
500 CModelDataArray::intersectWith(modelData,flagModification);
501 if (!isBaseLevel()) {
502 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
503 for (qint64 i = 0, mask = 0x1; i < 64; ++i,mask <<= 1) {
504 CModelDataArray *nextLevelModel = modelArray[i];
505 if (nextLevelModel) {
506 if ((dataArray & mask) != 0) {
507 nextLevelModel->intersectWith(modelDataLevelArray->getNextModelArray(i),modelMemMan,flagModification);
508 } else {
509 // alternative is to remove next level data
510 nextLevelModel->setData(false);
511 }
512 if (nextLevelModel->getDataArray() == 0) {
513 setLevelFlagIndex(i,false);
514 }
515 }
516 }
517 }
518 } else {
519 // modelData has a smaller interval than this
520 qint64 modelDataArray = modelData->getDataArray();
521 if (modelDataArray != 0) {
522 if (getLevelFlag(modelDataBegTag)) {
523 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
524 // intersect modelData with next level
525 for (qint64 i = 0; i < 64; ++i) {
526 if (i != arrayIndex) {
527 CModelDataArray *nextLevelModel = modelArray[i];
528 // alternative is to remove next level data
529 if (nextLevelModel) {
530 nextLevelModel->setData(false);
531 }
532 }
533 }
534 CModelDataArray *nextLevelModel = modelArray[arrayIndex];
535 if (nextLevelModel) {
536 nextLevelModel->intersectWith(modelData,modelMemMan,flagModification);
537 setLevelData(false);
538 setLevelFlagIndex(arrayIndex,nextLevelModel->getDataArray() != 0);
539 } else {
540 setLevelData(false);
541 }
542 } else {
543 setData(false);
544 }
545 }
546 }
547 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
548 // modelData has a larger interval than this
549 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
550 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
551 intersectWith(modelDataLevelArray->getNextModelArray(arrayIndex),modelMemMan,flagModification);
552 } else {
553 // modelData has another range than this
554 // resulting in no intersection
555 setData(false);
556 }
557 } else {
558 setData(false);
559 }
560 return this;
561 }
562
563
564 CModelDataArray *CModelDataLevelArray::unionWith(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
565 if (modelData) {
566 qint64 modelDataBegTag = modelData->getBeginTag();
567 qint64 modelDataEndTag = modelData->getEndTag();
568 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
569 qint64 modelDataTagSize = modelData->getTagSize();
570 if (tagSize == modelDataTagSize) {
571 // modelData has the same interval as this
572 CModelDataArray::unionWith(modelData,flagModification);
573 if (!isBaseLevel()) {
574 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
575 for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArray; ++i,mask <<= 1) {
576 qint64 modelDataArray = modelDataLevelArray->getDataArray();
577 if ((modelDataArray & mask) != 0) {
578 CModelDataArray *nextLevelModel = createNextModelArray(i,modelMemMan);
579 if (nextLevelModel) {
580 nextLevelModel->unionWith(modelDataLevelArray->getNextModelArray(i),modelMemMan,flagModification);
581 }
582 }
583 }
584 }
585 } else {
586 // modelData has a smaller interval than this
587 qint64 modelDataArray = modelData->getDataArray();
588 if (modelDataArray != 0) {
589 // intersect modelData with next level
590 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
591 setLevelFlagIndex(arrayIndex,true);
592 CModelDataArray *nextLevelModel = createNextModelArray(arrayIndex,modelMemMan);
593 if (nextLevelModel) {
594 nextLevelModel->unionWith(modelData,modelMemMan,flagModification);
595 }
596 }
597 }
598 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
599 // modelData has a larger interval than this
600 // executing this block produces mistakes, call extendModel before
601 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
602 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
603 this->unionWith(modelDataLevelArray->getNextModelArray(arrayIndex),modelMemMan,flagModification);
604 }
605 }
606 return this;
607 }
608
609
610 CModelDataArray *CModelDataLevelArray::copyFrom(CModelDataArray *modelData, bool *flagModification) {
611 return copyFrom(modelData,0,flagModification);
612 }
613
614 CModelDataArray *CModelDataLevelArray::copyFrom(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
615 if (modelData) {
616 qint64 modelDataBegTag = modelData->getBeginTag();
617 qint64 modelDataEndTag = modelData->getEndTag();
618 if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) {
619 qint64 modelDataTagSize = modelData->getTagSize();
620 if (tagSize == modelDataTagSize) {
621 // modelData has the same interval as this
622 CModelDataArray::copyFrom(modelData,flagModification);
623 if (!isBaseLevel()) {
624 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
625 for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArray; ++i,mask <<= 1) {
626 CModelDataArray *nextLevelModel = modelArray[i];
627 if ((dataArray & mask) != 0) {
628 nextLevelModel = createNextModelArray(i,modelMemMan);
629 }
630 if (nextLevelModel) {
631 if ((dataArray & mask) != 0) {
632 nextLevelModel->copyFrom(modelDataLevelArray->getNextModelArray(i),modelMemMan,flagModification);
633 } else {
634 // alternative is to remove next level data
635 nextLevelModel->setData(false);
636 }
637 }
638 }
639 }
640 } else {
641 // modelData has a smaller interval than this
642 qint64 modelDataArray = modelData->getDataArray();
643 setLevelData(false);
644 if (modelDataArray != 0) {
645 qint64 arrayIndex = getArrayIndex(modelDataBegTag);
646 // intersect modelData with next level
647 for (qint64 i = 0; i < 64; ++i) {
648 if (i != arrayIndex) {
649 CModelDataArray *nextLevelModel = modelArray[i];
650 // alternative is to remove next level data
651 if (nextLevelModel) {
652 nextLevelModel->setData(false);
653 }
654 }
655 }
656 CModelDataArray *nextLevelModel = createNextModelArray(arrayIndex,modelMemMan);
657 nextLevelModel->copyFrom(modelData,modelMemMan,flagModification);
658 if (nextLevelModel->getDataArray() != 0) {
659 setLevelFlagIndex(arrayIndex,true);
660 }
661 }
662 }
663 } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) {
664 // modelData has a larger interval than this
665 // executing this block produces mistakes, call extendModel before
666 CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData;
667 qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag);
668 copyFrom(modelDataLevelArray->getNextModelArray(arrayIndex),modelMemMan,flagModification);
669 } else {
670 // modelData has another range than this
671 // executing this block produces mistakes, call extendModel before
672 setData(false);
673 }
674 } else {
675 setData(false);
676 }
677 return this;
678 }
679
680
681 bool CModelDataLevelArray::isFullConstructed() {
682 for (qint64 i = 0; i < dataSize; ++i) {
683 if (modelArray[i] == 0) {
684 return false;
685 }
686 }
687 for (qint64 i = 0; i < dataSize; ++i) {
688 if (!modelArray[i]->isFullConstructed()) {
689 return false;
690 }
691 }
692 return true;
693 }
694
695
696
697 CModelDataArray *CModelDataLevelArray::extendModel(CModelDataArray *modelData, qint64 minTag, CDataArrayMemoryManager *modelMemMan) {
698 if (!modelData) {
699 modelData = modelMemMan->allocateModelDataArray();
700 qint64 extTagSize = dataSize;
701 qint64 extBegTagDiff = minTag % extTagSize;
702 qint64 extBegTag = minTag - extBegTagDiff;
703 modelData->setBounds(extBegTag,extTagSize);
704 }
705 return extendModel(modelData,minTag,minTag,modelMemMan);
706 }
707
708
709 CModelDataArray *CModelDataLevelArray::extendModel(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan) {
710 if (minModelDataExt) {
711 if (!modelData) {
712 if (minModelDataExt->isBaseLevel()) {
713 modelData = modelMemMan->allocateModelDataArray();
714 } else {
715 modelData = modelMemMan->allocateModelDataLevelArray();
716 }
717 modelData->init(minModelDataExt->getBeginTag(),minModelDataExt->getTagSize());
718 }
719 return extendModel(modelData,minModelDataExt->getBeginTag(),minModelDataExt->getEndTag(),modelMemMan);
720 } else {
721 return modelData;
722 }
723 }
724
725
726
727 CModelDataArray *CModelDataLevelArray::extendModel(CModelDataArray *modelData, qint64 minBegTag, qint64 minEndTag, CDataArrayMemoryManager *modelMemMan) {
728 CModelDataArray *extendedModel = modelData;
729
730 //for (qint64 i = 0; i < 64; ++i) {
731 // if (!extendedModel->isBaseLevel()) {
732 // if (((CModelDataLevelArray *)extendedModel)->getNextModelArray(i) == extendedModel) {
733 // bool bug = true;
734 // }
735 // }
736 //}
737
738
739 qint64 nBegTag = extendedModel->getBeginTag();
740 while (minBegTag < nBegTag) {
741 CModelDataLevelArray *nextModelExtension = modelMemMan->allocateModelDataLevelArray();
742 //if (nextModelExtension == extendedModel) {
743 // bool bug = true;
744 //}
745 qint64 extTagSize = extendedModel->getTagSize() * dataSize;
746 qint64 extBegTagDiff = nBegTag % extTagSize;
747 qint64 extBegTag = nBegTag - extBegTagDiff;
748 nextModelExtension->init(extBegTag,extTagSize);
749 qint64 arrayIndex = nextModelExtension->getArrayIndex(nBegTag);
750 nextModelExtension->setNextModelArray(arrayIndex,extendedModel);
751 extendedModel = nextModelExtension;
752 nBegTag = extendedModel->getBeginTag();
753 }
754
755 //for (qint64 i = 0; i < 64; ++i) {
756 // if (!extendedModel->isBaseLevel()) {
757 // if (((CModelDataLevelArray *)extendedModel)->getNextModelArray(i) == extendedModel) {
758 // bool bug = true;
759 // }
760 // }
761 //}
762
763
764 nBegTag = extendedModel->getBeginTag();
765 qint64 nEndTag = extendedModel->getEndTag();
766 while (minEndTag > nEndTag) {
767 CModelDataLevelArray *nextModelExtension = modelMemMan->allocateModelDataLevelArray();
768 //if (nextModelExtension == extendedModel) {
769 // bool bug = true;
770 //}
771
772 qint64 extTagSize = extendedModel->getTagSize() * dataSize;
773 qint64 extBegTagDiff = nBegTag % extTagSize;
774 qint64 extBegTag = nBegTag - extBegTagDiff;
775 nextModelExtension->init(extBegTag,extTagSize);
776 qint64 arrayIndex = nextModelExtension->getArrayIndex(nBegTag);
777 nextModelExtension->setNextModelArray(arrayIndex,extendedModel);
778 extendedModel = nextModelExtension;
779 nBegTag = extendedModel->getBeginTag();
780 nEndTag = extendedModel->getEndTag();
781 }
782
783 //for (qint64 i = 0; i < 64; ++i) {
784 // if (!extendedModel->isBaseLevel()) {
785 // if (((CModelDataLevelArray *)extendedModel)->getNextModelArray(i) == extendedModel) {
786 // bool bug = true;
787 // }
788 // }
789 //}
790
791 return extendedModel;
792 }
793
794
795 CModelDataArray *CModelDataLevelArray::reduceModel(CModelDataArray *modelData) {
796 if (modelData) {
797 qint64 modelDataArray = modelData->getDataArray();
798 if (modelDataArray == 0) {
799 return 0;
800 } else {
801 if (modelData->isBaseLevel()) {
802 return modelData;
803 }
804 qint64 onlyInd = -1;
805 for (qint64 i = 0, mask = 0x1; i < 64; ++i,mask <<= 1) {
806 if ((modelDataArray & mask) != 0) {
807 if (onlyInd != -1) {
808 return modelData;
809 } else {
810 onlyInd = i;
811 }
812 }
813 }
814 CModelDataArray *reducedModelData = ((CModelDataLevelArray *)modelData)->getNextModelArray(onlyInd);
815 reducedModelData = reduceModel(reducedModelData);
816 return reducedModelData;
817 }
818 }
819 return 0;
820 }
821
822
823
824 CModelDataArray *CModelDataLevelArray::extendAndUnionModelWith(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
825 modelData = extendModel(modelData,minModelDataExt,modelMemMan);
826 if (modelData) {
827 modelData->unionWith(minModelDataExt,modelMemMan,flagModification);
828 }
829 return modelData;
830 }
831
832 CModelDataArray *CModelDataLevelArray::extendAndCopyModelFrom(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
833 modelData = extendModel(modelData,minModelDataExt,modelMemMan);
834 if (modelData) {
835 modelData->copyFrom(minModelDataExt,modelMemMan,flagModification);
836 modelData = reduceModel(modelData);
837 }
838 return modelData;
839 }
840
841 CModelDataArray *CModelDataLevelArray::reduceAndIntersecModelWith(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
842 if (modelData) {
843 modelData->intersectWith(minModelDataExt,modelMemMan,flagModification);
844 modelData = reduceModel(modelData);
845 }
846 return modelData;
847 }
848
849 CModelDataArray *CModelDataLevelArray::extendAndSetFlag(CModelDataArray *modelData, qint64 tag, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
850 modelData = extendModel(modelData,tag,modelMemMan);
851 if (!modelData->getFlag(tag)) {
852 modelData->setFlag(tag,true,modelMemMan);
853 if (flagModification) {
854 *flagModification = true;
855 }
856 }
857 return modelData;
858 }
859
860
861 }; // end namespace Container
862
863 }; // end namespace Utilities
864
865 }; // end namespace Konclude