Debian Codegraph @

Source/Utilities/Container/CModelDataArray.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 "CModelDataArray.h"
22
23
24 namespace Konclude {
25
26 namespace Utilities {
27
28 namespace Container {
29
30 CModelDataArray::CModelDataArray() {
31 bitIndMask = dataSize-1;
32 begTag = 0;
33 tagSize = endTag = dataSize;
34 bitIndShift = 0;
35 dataArray = 0;
36 }
37
38
39 CModelDataArray::CModelDataArray(qint64 tagBegin, qint64 tagBegEndSize) {
40 setBounds(tagBegin,tagBegEndSize);
41 dataArray = 0;
42 }
43
44
45 CModelDataArray::~CModelDataArray() {
46 }
47
48
49 CModelDataArray *CModelDataArray::init(qint64 tagBegin, qint64 tagBegEndSize) {
50 setBounds(tagBegin,tagBegEndSize);
51 dataArray = 0;
52 return this;
53 }
54
55
56
57 CModelDataArray *CModelDataArray::setBounds(qint64 tagBegin, qint64 tagBegEndSize) {
58 begTag = tagBegin;
59 tagSize = tagBegEndSize;
60 endTag = begTag + tagSize;
61
62 bitIndShift = CMath::log2(tagSize>>log2DataSize);
63 bitIndMask = dataSize-1;
64 return this;
65 }
66
67
68 bool CModelDataArray::isBaseLevel() {
69 return true;
70 }
71
72 qint64 CModelDataArray::getModelLevel() {
73 return 0;
74 }
75
76 qint64 CModelDataArray::getBeginTag() {
77 return begTag;
78 }
79
80 qint64 CModelDataArray::getEndTag() {
81 return endTag;
82 }
83
84 qint64 CModelDataArray::getTagSize() {
85 return tagSize;
86 }
87
88 qint64 CModelDataArray::getDataArray() {
89 return dataArray;
90 }
91
92
93 CModelDataArray *CModelDataArray::setData(bool value) {
94 if (value == false) {
95 dataArray = 0;
96 } else {
97 dataArray = Q_INT64_C(0xffffffffffffffff);
98 }
99 return this;
100 }
101
102 CModelDataArray *CModelDataArray::setLevelData(bool value) {
103 if (value == false) {
104 dataArray = 0;
105 } else {
106 dataArray = Q_INT64_C(0xffffffffffffffff);
107 }
108 return this;
109 }
110
111
112 bool CModelDataArray::setFlag(qint64 tag, bool flag, CDataArrayMemoryManager *modelMemMan) {
113 return setFlag(tag,flag);;
114 }
115
116
117 CModelDataArray *CModelDataArray::getBaseModel(qint64 beginTag) {
118 if (begTag != beginTag) {
119 return 0;
120 } else {
121 return this;
122 }
123 }
124
125
126 bool CModelDataArray::setFlag(qint64 tag, bool flag) {
127 if (begTag <= tag && tag < endTag) {
128 qint64 index = (tag-begTag) >> bitIndShift;
129 qint64 bitIndex = index & bitIndMask;
130 if (flag) {
131 dataArray |= qint64(1)<<bitIndex;
132 } else {
133 dataArray &= ~(qint64(1)<<bitIndex);
134 }
135 return true;
136 }
137 return false;
138 }
139
140 bool CModelDataArray::getFlag(qint64 tag) {
141 if (begTag <= tag && tag < endTag) {
142 qint64 index = (tag-begTag) >> bitIndShift;
143 qint64 bitIndex = index & bitIndMask;
144 return (dataArray & qint64(1)<<bitIndex) != 0;
145 }
146 return false;
147 }
148
149
150 bool CModelDataArray::setLevelFlag(qint64 tag, bool flag) {
151 return CModelDataArray::setFlag(tag,flag);
152 }
153
154 bool CModelDataArray::getLevelFlag(qint64 tag) {
155 return CModelDataArray::getFlag(tag);
156 }
157
158
159 bool CModelDataArray::setLevelFlagIndex(qint64 index, bool flag) {
160 if (index >= 0 && index < dataSize) {
161 qint64 bitIndex = index;
162 if (flag) {
163 dataArray |= qint64(1)<<bitIndex;
164 } else {
165 dataArray &= ~(qint64(1)<<bitIndex);
166 }
167 return true;
168 }
169 return false;
170 }
171
172 bool CModelDataArray::getLevelFlagIndex(qint64 index) {
173 if (index >= 0 && index < dataSize) {
174 qint64 bitIndex = index;
175 return (dataArray & qint64(1)<<bitIndex) != 0;
176 }
177 return false;
178 }
179
180
181 qint64 CModelDataArray::countFlags() {
182 qint64 count = 0;
183 for (qint64 mask = 0x1, cn = 0; cn < dataSize; mask<<=1,++cn) {
184 count += (bool)(mask & dataArray);
185 }
186 return count;
187 }
188
189 bool CModelDataArray::isEmpty() {
190 return dataArray == 0;
191 }
192
193
194 qint64 CModelDataArray::getFirstFlagTag() {
195 qint64 flagTag = begTag;
196 for (qint64 mask = 0x1, cn = 0; cn < dataSize; mask<<=1,++cn,++flagTag) {
197 if ((mask & dataArray) != 0) {
198 break;
199 }
200 }
201 return flagTag;
202 }
203
204 qint64 CModelDataArray::getLastFlagTag() {
205 qint64 flagTag = endTag-1;
206 for (qint64 mask = Q_INT64_C(0x8000000000000000), cn = 0; cn < dataSize; mask>>=1,++cn,--flagTag) {
207 if ((mask & dataArray) != 0) {
208 break;
209 }
210 }
211 return flagTag;
212 }
213
214
215 CModelDataArray *CModelDataArray::intersectWith(CModelDataArray *modelData, bool *flagModification) {
216 if (modelData) {
217 CModelDataArray *testModelData = 0;
218 if (isBaseLevel()) {
219 testModelData = modelData->getBaseModel(begTag);
220 } else {
221 testModelData = modelData;
222 }
223 if (testModelData && begTag == testModelData->getBeginTag() && tagSize == testModelData->getTagSize()) {
224 qint64 dataArrayBackup = dataArray;
225 dataArray &= testModelData->dataArray;
226 if (dataArrayBackup != dataArray && flagModification) {
227 *flagModification = true;
228 }
229 } else {
230 if (0 != dataArray && flagModification) {
231 *flagModification = true;
232 }
233 dataArray = 0;
234 }
235 } else {
236 if (0 != dataArray && flagModification) {
237 *flagModification = true;
238 }
239 dataArray = 0;
240 }
241 return this;
242 }
243
244
245 CModelDataArray *CModelDataArray::unionWith(CModelDataArray *modelData, bool *flagModification) {
246 if (modelData) {
247 if (begTag == modelData->getBeginTag() && tagSize == modelData->getTagSize()) {
248 qint64 dataArrayBackup = dataArray;
249 dataArray |= modelData->dataArray;
250 if (dataArrayBackup != dataArray && flagModification) {
251 *flagModification = true;
252 }
253 }
254 }
255 return this;
256 }
257
258
259 CModelDataArray *CModelDataArray::intersectWith(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
260 if (modelData) {
261 CModelDataArray *testModelData = 0;
262 if (isBaseLevel()) {
263 testModelData = modelData->getBaseModel(begTag);
264 } else {
265 testModelData = modelData;
266 }
267 if (testModelData && begTag == testModelData->getBeginTag() && tagSize == testModelData->getTagSize()) {
268 qint64 dataArrayBackup = dataArray;
269 dataArray &= testModelData->dataArray;
270 if (dataArrayBackup != dataArray && flagModification) {
271 *flagModification = true;
272 }
273 } else {
274 if (0 != dataArray && flagModification) {
275 *flagModification = true;
276 }
277 dataArray = 0;
278 }
279 } else {
280 if (0 != dataArray && flagModification) {
281 *flagModification = true;
282 }
283 dataArray = 0;
284 }
285 return this;
286 }
287
288
289 CModelDataArray *CModelDataArray::unionWith(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
290 if (modelData) {
291 if (begTag == modelData->getBeginTag() && tagSize == modelData->getTagSize()) {
292 qint64 dataArrayBackup = dataArray;
293 dataArray |= modelData->dataArray;
294 if (dataArrayBackup != dataArray && flagModification) {
295 *flagModification = true;
296 }
297 }
298 }
299 return this;
300 }
301
302
303 bool CModelDataArray::needsExtension(qint64 minBegTag, qint64 minEndTag) {
304 if (minBegTag < begTag || endTag > minEndTag) {
305 return true;
306 } else {
307 return false;
308 }
309 }
310
311
312 bool CModelDataArray::needsExtension(qint64 tag) {
313 if (tag < begTag || endTag > tag) {
314 return true;
315 } else {
316 return false;
317 }
318 }
319
320
321 CModelDataArray *CModelDataArray::copyFrom(CModelDataArray *modelData, bool *flagModification) {
322 if (modelData) {
323 if (begTag == modelData->getBeginTag() && tagSize == modelData->getTagSize()) {
324 qint64 dataArrayBackup = dataArray;
325 dataArray = modelData->getDataArray();
326 if (dataArrayBackup != dataArray && flagModification) {
327 *flagModification = true;
328 }
329 }
330 } else {
331 setData(false);
332 }
333 return this;
334 }
335
336 CModelDataArray *CModelDataArray::copyFrom(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) {
337 if (modelData) {
338 if (begTag == modelData->getBeginTag() && tagSize == modelData->getTagSize()) {
339 qint64 dataArrayBackup = dataArray;
340 dataArray = modelData->getDataArray();
341 if (dataArrayBackup != dataArray && flagModification) {
342 *flagModification = true;
343 }
344 }
345 } else {
346 setData(false);
347 }
348 return this;
349 }
350
351
352 bool CModelDataArray::hasIntersectionWith(CModelDataArray *modelData) {
353 if (modelData) {
354 CModelDataArray *baseModelTag = modelData->getBaseModel(begTag);
355 if (baseModelTag && begTag == baseModelTag->getBeginTag() && tagSize == baseModelTag->getTagSize()) {
356 return (dataArray & baseModelTag->getDataArray()) != 0;
357 }
358 }
359 return false;
360 }
361
362 qint64 CModelDataArray::countIntersectionWith(CModelDataArray *modelData) {
363 qint64 inCount = 0;
364 if (modelData) {
365 CModelDataArray *baseModelTag = modelData->getBaseModel(begTag);
366 if (baseModelTag && begTag == baseModelTag->getBeginTag() && tagSize == baseModelTag->getTagSize()) {
367 qint64 otherBaseDataArray = baseModelTag->getDataArray();
368 qint64 intersectDataArray = dataArray & otherBaseDataArray;
369 if ((intersectDataArray) != 0) {
370 for (qint64 mask = 0x1, cn = 0; cn < dataSize; mask<<=1,++cn) {
371 if ((mask & intersectDataArray) != 0) {
372 inCount++;
373 }
374 }
375
376 }
377 }
378 }
379 return inCount;
380 }
381
382 bool CModelDataArray::isSuperSetTo(CModelDataArray *modelData) {
383 if (!modelData || modelData->isEmpty()) {
384 return true;
385 }
386 if (modelData->getFirstFlagTag() < begTag) {
387 return false;
388 }
389 if (modelData->getLastFlagTag() < endTag) {
390 return false;
391 }
392 CModelDataArray *testModelData = modelData;
393 if (isBaseLevel()) {
394 testModelData = modelData->getBaseModel(begTag);
395 }
396
397 qint64 modelDataArray = testModelData->getDataArray();
398 return (dataArray & modelDataArray) == modelDataArray;
399 }
400
401
402 bool CModelDataArray::isSubsetFrom(CModelDataArray *modelData) {
403 if (isEmpty()) {
404 return true;
405 }
406 if (modelData) {
407 CModelDataArray *testModelData = modelData;
408 if (isBaseLevel()) {
409 testModelData = modelData->getBaseModel(begTag);
410 }
411 if (!testModelData) {
412 return false;
413 }
414 return (dataArray & testModelData->getDataArray()) == dataArray;
415 }
416 return false;
417 }
418
419
420 bool CModelDataArray::needsExtension(CModelDataArray *otherModelData) {
421 if (otherModelData) {
422 return needsExtension(otherModelData->getBeginTag(),otherModelData->getEndTag());
423 }
424 return false;
425 }
426
427 bool CModelDataArray::isFullConstructed() {
428 return true;
429 }
430
431
432 }; // end namespace Container
433
434 }; // end namespace Utilities
435
436 }; // end namespace Konclude