/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CModelDataLevelArray.h" namespace Konclude { namespace Utilities { namespace Container { CModelDataLevelArray::CModelDataLevelArray() : CModelDataArray() { for (qint64 i = 0; i < dataSize; ++i) { modelArray[i] = 0; } level = 0; } CModelDataLevelArray::CModelDataLevelArray(qint64 tagBegin, qint64 tagBegEndSize) : CModelDataArray(tagBegin,tagBegEndSize) { for (qint64 i = 0; i < dataSize; ++i) { modelArray[i] = 0; } } CModelDataLevelArray::~CModelDataLevelArray() { } CModelDataArray *CModelDataLevelArray::init(qint64 tagBegin, qint64 tagBegEndSize) { CModelDataArray::init(tagBegin,tagBegEndSize); for (qint64 i = 0; i < dataSize; ++i) { modelArray[i] = 0; } return this; } bool CModelDataLevelArray::isBaseLevel() { return tagSize == dataSize; } qint64 CModelDataLevelArray::getModelLevel() { return level; } CModelDataLevelArray *CModelDataLevelArray::setBounds(qint64 tagBegin, qint64 tagBegEndSize) { CModelDataArray::setBounds(tagBegin,tagBegEndSize); level = bitIndShift / log2DataSize; return this; } CModelDataArray **CModelDataLevelArray::getModelArray() { return modelArray; } CModelDataArray *CModelDataLevelArray::getNextModelArray(qint64 index) { return modelArray[index]; } CModelDataArray *CModelDataLevelArray::getBaseModel(qint64 beginTag) { CModelDataArray *modelData = getNextModelArray(getArrayIndex(beginTag)); if (modelData) { return modelData->getBaseModel(beginTag); } else { return 0; } } qint64 CModelDataLevelArray::getFirstFlagTag() { for (qint64 mask = 0x1, idx = 0; idx < dataSize; mask<<=1,++idx) { if ((mask & dataArray) != 0) { CModelDataArray *model = modelArray[idx]; return model->getFirstFlagTag(); } } return endTag; } qint64 CModelDataLevelArray::getLastFlagTag() { for (qint64 mask = Q_INT64_C(0x8000000000000000), idx = dataSize-1; idx >= 0; mask>>=1,--idx) { if ((mask & dataArray) != 0) { CModelDataArray *model = modelArray[idx]; return model->getLastFlagTag(); } } return begTag; } CModelDataArray *CModelDataLevelArray::setNextModelArray(qint64 index, CModelDataArray *nextModelDataArray) { modelArray[index] = nextModelDataArray; if (nextModelDataArray && nextModelDataArray->getDataArray() != 0) { setLevelFlagIndex(index,true); } else { setLevelFlagIndex(index,false); } return this; } CModelDataLevelArray *CModelDataLevelArray::setData(bool value) { CModelDataArray::setData(value); for (qint64 i = 0; i < dataSize; ++i) { CModelDataArray *modelData = modelArray[i]; if (modelData) { modelData->setData(value); } } return this; } CModelDataArray *CModelDataLevelArray::createNextModelArray(qint64 index, CDataArrayMemoryManager *modelMemMan) { CModelDataArray *modelData = modelArray[index]; if (!modelData && modelMemMan) { if (level <= 1) { modelData = modelMemMan->allocateModelDataArray(); } else { modelData = modelMemMan->allocateModelDataLevelArray(); } qint64 nextTagSize = tagSize/dataSize; qint64 nextBegTag = begTag + index*nextTagSize; modelData->init(nextBegTag,nextTagSize); modelArray[index] = modelData; } return modelData; } bool CModelDataLevelArray::setFlag(qint64 tag, bool flag, CDataArrayMemoryManager *modelMemMan) { if (flag) { CModelDataArray::setFlag(tag,flag); } if (begTag >= tag && tag < endTag) { qint64 index = (tag-begTag) >> bitIndShift; qint64 arrayIndex = index & bitIndMask; CModelDataArray *modelData = createNextModelArray(arrayIndex,modelMemMan); if (modelData->setFlag(tag,flag)) { if (modelData->getDataArray() == 0) { CModelDataArray::setLevelFlagIndex(arrayIndex,false); } return true; } } return false; } bool CModelDataLevelArray::setFlag(qint64 tag, bool flag) { if (begTag >= tag && tag < endTag) { if (flag) { CModelDataArray::setFlag(tag,flag); } qint64 index = (tag-begTag) >> bitIndShift; qint64 arrayIndex = index & bitIndMask; CModelDataArray *modelData = modelArray[arrayIndex]; if (modelData) { if (modelData->setFlag(tag,flag)) { if (modelData->getDataArray() == 0) { CModelDataArray::setFlag(tag,false); } return true; } } } return false; } bool CModelDataLevelArray::getFlag(qint64 tag) { if (begTag >= tag && tag < endTag) { qint64 index = (tag-begTag) >> bitIndShift; qint64 arrayIndex = index & bitIndMask; CModelDataArray *modelData = modelArray[arrayIndex]; if (modelData) { return modelData->getFlag(tag); } } return 0; } qint64 CModelDataLevelArray::getArrayIndex(qint64 tag) { qint64 index = (tag-begTag) >> bitIndShift; qint64 arrayIndex = index & bitIndMask; return arrayIndex; } CModelDataArray *CModelDataLevelArray::intersectWith(CModelDataArray *modelData, bool *flagModification) { return intersectWith(modelData,0,flagModification); } CModelDataArray *CModelDataLevelArray::unionWith(CModelDataArray *modelData, bool *flagModification) { return unionWith(modelData,0,flagModification); } bool CModelDataLevelArray::testHasIntersectBetween(CModelDataArray *modelData1, CModelDataArray *modelData2) { if (!modelData1 || !modelData2) { return false; } else { CModelDataLevelArray *modelDataLevel = dynamic_cast(modelData1); if (modelDataLevel) { modelData1->hasIntersectionWith(modelData2); } return modelData2->hasIntersectionWith(modelData1); } } bool CModelDataLevelArray::testIsSubsetBetween(CModelDataArray *modelData1, CModelDataArray *modelData2) { if (!modelData1) { return true; } else if (!modelData2) { return false; } else { CModelDataLevelArray *modelDataLevel = dynamic_cast(modelData1); if (modelDataLevel) { return modelData1->isSubsetFrom(modelData2); } else { return modelData2->isSuperSetTo(modelData1); } } } bool CModelDataLevelArray::isSubsetFrom(CModelDataArray *modelData) { if (dataArray == 0) { return true; } if (modelData) { qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray == 0 && dataArray != 0) { return false; } qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this qint64 dataArrayIntersection = dataArray & modelDataArray; if (dataArrayIntersection != dataArray) { return false; } else { // test possible subset if (isBaseLevel()) { return true; } else { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) { if ((dataArrayIntersection & mask) != 0) { CModelDataArray *nextLevelModel = modelArray[i]; if (!nextLevelModel->isSubsetFrom(modelDataLevelArray->getNextModelArray(i))) { return false; } } } return true; } } } else { // modelData has a smaller interval than this if (modelDataArray != 0 && getLevelFlag(modelDataBegTag)) { qint64 arrayIndex = getArrayIndex(modelDataBegTag); if ((1<isSubsetFrom(modelData); } } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); return isSubsetFrom(modelDataLevelArray->getNextModelArray(arrayIndex)); } } return false; } bool CModelDataLevelArray::isSuperSetTo(CModelDataArray *modelData) { if (modelData == 0) { return true; } if (modelData) { qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray != 0 && dataArray == 0) { return false; } qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this qint64 dataArrayIntersection = dataArray & modelDataArray; if (dataArrayIntersection != modelDataArray) { return false; } else { // test possible subset if (isBaseLevel()) { return true; } else { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) { if ((dataArrayIntersection & mask) != 0) { CModelDataArray *nextLevelModel = modelArray[i]; if (!nextLevelModel->isSuperSetTo(modelDataLevelArray->getNextModelArray(i))) { return false; } } } return true; } } } else { // modelData has a smaller interval than this if (getLevelFlag(modelDataBegTag)) { qint64 arrayIndex = getArrayIndex(modelDataBegTag); // test modelData subset with next level CModelDataArray *nextLevelModel = modelArray[arrayIndex]; return nextLevelModel->isSuperSetTo(modelData); } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); if ((1<getNextModelArray(arrayIndex)); } } } return false; } bool CModelDataLevelArray::hasIntersectionWith(CModelDataArray *modelData) { if (modelData) { qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this qint64 modelDataArray = modelData->getDataArray(); qint64 dataArrayIntersection = dataArray & modelDataArray; if (dataArrayIntersection != 0) { // test possible intersections if (isBaseLevel()) { return true; } else { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) { if ((dataArrayIntersection & mask) != 0) { CModelDataArray *nextLevelModel = modelArray[i]; if (nextLevelModel && nextLevelModel->hasIntersectionWith(modelDataLevelArray->getNextModelArray(i))) { return true; } } } } } } else { // modelData has a smaller interval than this qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray != 0 && getLevelFlag(modelDataBegTag)) { qint64 arrayIndex = getArrayIndex(modelDataBegTag); // test modelData intersection with next level CModelDataArray *nextLevelModel = modelArray[arrayIndex]; if (nextLevelModel && nextLevelModel->hasIntersectionWith(modelData)) { return true; } } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this if (dataArray != 0) { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); if (hasIntersectionWith(modelDataLevelArray->getNextModelArray(arrayIndex))) { return true; } } } } return false; } qint64 CModelDataLevelArray::countIntersectionWith(CModelDataArray *modelData) { qint64 inCount = 0; if (modelData) { qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this qint64 modelDataArray = modelData->getDataArray(); qint64 dataArrayIntersection = dataArray & modelDataArray; if (dataArrayIntersection != 0) { // test possible intersections if (isBaseLevel()) { inCount = CModelDataArray::countIntersectionWith(modelData); } else { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArrayIntersection; ++i,mask <<= 1) { if ((dataArrayIntersection & mask) != 0) { CModelDataArray *nextLevelModel = modelArray[i]; if (nextLevelModel) { inCount += nextLevelModel->countIntersectionWith(modelDataLevelArray->getNextModelArray(i)); } } } } } } else { // modelData has a smaller interval than this qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray != 0 && getLevelFlag(modelDataBegTag)) { qint64 arrayIndex = getArrayIndex(modelDataBegTag); // test modelData intersection with next level CModelDataArray *nextLevelModel = modelArray[arrayIndex]; if (nextLevelModel) { inCount += nextLevelModel->countIntersectionWith(modelData); } } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this if (dataArray != 0) { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); inCount += countIntersectionWith(modelDataLevelArray->getNextModelArray(arrayIndex)); } } } return inCount; } qint64 CModelDataLevelArray::countFlags() { qint64 count = 0; if (!isBaseLevel()) { for (qint64 i = 0, mask = 0x1; i < 64; ++i,mask <<= 1) { if ((dataArray & mask) != 0) { CModelDataArray *modelArray = getNextModelArray(i); if (modelArray) { count += modelArray->countFlags(); } } } } else { count = CModelDataArray::countFlags(); } return count; } CModelDataArray *CModelDataLevelArray::intersectWith(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { if (modelData) { qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this CModelDataArray::intersectWith(modelData,flagModification); if (!isBaseLevel()) { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64; ++i,mask <<= 1) { CModelDataArray *nextLevelModel = modelArray[i]; if (nextLevelModel) { if ((dataArray & mask) != 0) { nextLevelModel->intersectWith(modelDataLevelArray->getNextModelArray(i),modelMemMan,flagModification); } else { // alternative is to remove next level data nextLevelModel->setData(false); } if (nextLevelModel->getDataArray() == 0) { setLevelFlagIndex(i,false); } } } } } else { // modelData has a smaller interval than this qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray != 0) { if (getLevelFlag(modelDataBegTag)) { qint64 arrayIndex = getArrayIndex(modelDataBegTag); // intersect modelData with next level for (qint64 i = 0; i < 64; ++i) { if (i != arrayIndex) { CModelDataArray *nextLevelModel = modelArray[i]; // alternative is to remove next level data if (nextLevelModel) { nextLevelModel->setData(false); } } } CModelDataArray *nextLevelModel = modelArray[arrayIndex]; if (nextLevelModel) { nextLevelModel->intersectWith(modelData,modelMemMan,flagModification); setLevelData(false); setLevelFlagIndex(arrayIndex,nextLevelModel->getDataArray() != 0); } else { setLevelData(false); } } else { setData(false); } } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); intersectWith(modelDataLevelArray->getNextModelArray(arrayIndex),modelMemMan,flagModification); } else { // modelData has another range than this // resulting in no intersection setData(false); } } else { setData(false); } return this; } CModelDataArray *CModelDataLevelArray::unionWith(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { if (modelData) { qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this CModelDataArray::unionWith(modelData,flagModification); if (!isBaseLevel()) { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArray; ++i,mask <<= 1) { qint64 modelDataArray = modelDataLevelArray->getDataArray(); if ((modelDataArray & mask) != 0) { CModelDataArray *nextLevelModel = createNextModelArray(i,modelMemMan); if (nextLevelModel) { nextLevelModel->unionWith(modelDataLevelArray->getNextModelArray(i),modelMemMan,flagModification); } } } } } else { // modelData has a smaller interval than this qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray != 0) { // intersect modelData with next level qint64 arrayIndex = getArrayIndex(modelDataBegTag); setLevelFlagIndex(arrayIndex,true); CModelDataArray *nextLevelModel = createNextModelArray(arrayIndex,modelMemMan); if (nextLevelModel) { nextLevelModel->unionWith(modelData,modelMemMan,flagModification); } } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this // executing this block produces mistakes, call extendModel before CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); this->unionWith(modelDataLevelArray->getNextModelArray(arrayIndex),modelMemMan,flagModification); } } return this; } CModelDataArray *CModelDataLevelArray::copyFrom(CModelDataArray *modelData, bool *flagModification) { return copyFrom(modelData,0,flagModification); } CModelDataArray *CModelDataLevelArray::copyFrom(CModelDataArray *modelData, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { if (modelData) { qint64 modelDataBegTag = modelData->getBeginTag(); qint64 modelDataEndTag = modelData->getEndTag(); if (begTag <= modelDataBegTag && modelDataEndTag <= endTag) { qint64 modelDataTagSize = modelData->getTagSize(); if (tagSize == modelDataTagSize) { // modelData has the same interval as this CModelDataArray::copyFrom(modelData,flagModification); if (!isBaseLevel()) { CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; for (qint64 i = 0, mask = 0x1; i < 64 && mask <= dataArray; ++i,mask <<= 1) { CModelDataArray *nextLevelModel = modelArray[i]; if ((dataArray & mask) != 0) { nextLevelModel = createNextModelArray(i,modelMemMan); } if (nextLevelModel) { if ((dataArray & mask) != 0) { nextLevelModel->copyFrom(modelDataLevelArray->getNextModelArray(i),modelMemMan,flagModification); } else { // alternative is to remove next level data nextLevelModel->setData(false); } } } } } else { // modelData has a smaller interval than this qint64 modelDataArray = modelData->getDataArray(); setLevelData(false); if (modelDataArray != 0) { qint64 arrayIndex = getArrayIndex(modelDataBegTag); // intersect modelData with next level for (qint64 i = 0; i < 64; ++i) { if (i != arrayIndex) { CModelDataArray *nextLevelModel = modelArray[i]; // alternative is to remove next level data if (nextLevelModel) { nextLevelModel->setData(false); } } } CModelDataArray *nextLevelModel = createNextModelArray(arrayIndex,modelMemMan); nextLevelModel->copyFrom(modelData,modelMemMan,flagModification); if (nextLevelModel->getDataArray() != 0) { setLevelFlagIndex(arrayIndex,true); } } } } else if (begTag >= modelDataBegTag && modelDataEndTag >= endTag) { // modelData has a larger interval than this // executing this block produces mistakes, call extendModel before CModelDataLevelArray *modelDataLevelArray = (CModelDataLevelArray *)modelData; qint64 arrayIndex = modelDataLevelArray->getArrayIndex(begTag); copyFrom(modelDataLevelArray->getNextModelArray(arrayIndex),modelMemMan,flagModification); } else { // modelData has another range than this // executing this block produces mistakes, call extendModel before setData(false); } } else { setData(false); } return this; } bool CModelDataLevelArray::isFullConstructed() { for (qint64 i = 0; i < dataSize; ++i) { if (modelArray[i] == 0) { return false; } } for (qint64 i = 0; i < dataSize; ++i) { if (!modelArray[i]->isFullConstructed()) { return false; } } return true; } CModelDataArray *CModelDataLevelArray::extendModel(CModelDataArray *modelData, qint64 minTag, CDataArrayMemoryManager *modelMemMan) { if (!modelData) { modelData = modelMemMan->allocateModelDataArray(); qint64 extTagSize = dataSize; qint64 extBegTagDiff = minTag % extTagSize; qint64 extBegTag = minTag - extBegTagDiff; modelData->setBounds(extBegTag,extTagSize); } return extendModel(modelData,minTag,minTag,modelMemMan); } CModelDataArray *CModelDataLevelArray::extendModel(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan) { if (minModelDataExt) { if (!modelData) { if (minModelDataExt->isBaseLevel()) { modelData = modelMemMan->allocateModelDataArray(); } else { modelData = modelMemMan->allocateModelDataLevelArray(); } modelData->init(minModelDataExt->getBeginTag(),minModelDataExt->getTagSize()); } return extendModel(modelData,minModelDataExt->getBeginTag(),minModelDataExt->getEndTag(),modelMemMan); } else { return modelData; } } CModelDataArray *CModelDataLevelArray::extendModel(CModelDataArray *modelData, qint64 minBegTag, qint64 minEndTag, CDataArrayMemoryManager *modelMemMan) { CModelDataArray *extendedModel = modelData; //for (qint64 i = 0; i < 64; ++i) { // if (!extendedModel->isBaseLevel()) { // if (((CModelDataLevelArray *)extendedModel)->getNextModelArray(i) == extendedModel) { // bool bug = true; // } // } //} qint64 nBegTag = extendedModel->getBeginTag(); while (minBegTag < nBegTag) { CModelDataLevelArray *nextModelExtension = modelMemMan->allocateModelDataLevelArray(); //if (nextModelExtension == extendedModel) { // bool bug = true; //} qint64 extTagSize = extendedModel->getTagSize() * dataSize; qint64 extBegTagDiff = nBegTag % extTagSize; qint64 extBegTag = nBegTag - extBegTagDiff; nextModelExtension->init(extBegTag,extTagSize); qint64 arrayIndex = nextModelExtension->getArrayIndex(nBegTag); nextModelExtension->setNextModelArray(arrayIndex,extendedModel); extendedModel = nextModelExtension; nBegTag = extendedModel->getBeginTag(); } //for (qint64 i = 0; i < 64; ++i) { // if (!extendedModel->isBaseLevel()) { // if (((CModelDataLevelArray *)extendedModel)->getNextModelArray(i) == extendedModel) { // bool bug = true; // } // } //} nBegTag = extendedModel->getBeginTag(); qint64 nEndTag = extendedModel->getEndTag(); while (minEndTag > nEndTag) { CModelDataLevelArray *nextModelExtension = modelMemMan->allocateModelDataLevelArray(); //if (nextModelExtension == extendedModel) { // bool bug = true; //} qint64 extTagSize = extendedModel->getTagSize() * dataSize; qint64 extBegTagDiff = nBegTag % extTagSize; qint64 extBegTag = nBegTag - extBegTagDiff; nextModelExtension->init(extBegTag,extTagSize); qint64 arrayIndex = nextModelExtension->getArrayIndex(nBegTag); nextModelExtension->setNextModelArray(arrayIndex,extendedModel); extendedModel = nextModelExtension; nBegTag = extendedModel->getBeginTag(); nEndTag = extendedModel->getEndTag(); } //for (qint64 i = 0; i < 64; ++i) { // if (!extendedModel->isBaseLevel()) { // if (((CModelDataLevelArray *)extendedModel)->getNextModelArray(i) == extendedModel) { // bool bug = true; // } // } //} return extendedModel; } CModelDataArray *CModelDataLevelArray::reduceModel(CModelDataArray *modelData) { if (modelData) { qint64 modelDataArray = modelData->getDataArray(); if (modelDataArray == 0) { return 0; } else { if (modelData->isBaseLevel()) { return modelData; } qint64 onlyInd = -1; for (qint64 i = 0, mask = 0x1; i < 64; ++i,mask <<= 1) { if ((modelDataArray & mask) != 0) { if (onlyInd != -1) { return modelData; } else { onlyInd = i; } } } CModelDataArray *reducedModelData = ((CModelDataLevelArray *)modelData)->getNextModelArray(onlyInd); reducedModelData = reduceModel(reducedModelData); return reducedModelData; } } return 0; } CModelDataArray *CModelDataLevelArray::extendAndUnionModelWith(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { modelData = extendModel(modelData,minModelDataExt,modelMemMan); if (modelData) { modelData->unionWith(minModelDataExt,modelMemMan,flagModification); } return modelData; } CModelDataArray *CModelDataLevelArray::extendAndCopyModelFrom(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { modelData = extendModel(modelData,minModelDataExt,modelMemMan); if (modelData) { modelData->copyFrom(minModelDataExt,modelMemMan,flagModification); modelData = reduceModel(modelData); } return modelData; } CModelDataArray *CModelDataLevelArray::reduceAndIntersecModelWith(CModelDataArray *modelData, CModelDataArray *minModelDataExt, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { if (modelData) { modelData->intersectWith(minModelDataExt,modelMemMan,flagModification); modelData = reduceModel(modelData); } return modelData; } CModelDataArray *CModelDataLevelArray::extendAndSetFlag(CModelDataArray *modelData, qint64 tag, CDataArrayMemoryManager *modelMemMan, bool *flagModification) { modelData = extendModel(modelData,tag,modelMemMan); if (!modelData->getFlag(tag)) { modelData->setFlag(tag,true,modelMemMan); if (flagModification) { *flagModification = true; } } return modelData; } }; // end namespace Container }; // end namespace Utilities }; // end namespace Konclude