/*
* 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 "CReapplyConceptLabelSet.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Process {
CReapplyConceptLabelSet::CReapplyConceptLabelSet(CProcessContext* processContext) : mProcessContext(processContext),mConceptDesDepMap(processContext) {
mConceptDesLinker = nullptr;
mPrevConceptDesLinker = nullptr;
mCoreConDesLinker = nullptr;
mConceptCount = 0;
mAdditionalConceptDesDepMap = nullptr;
}
CReapplyConceptLabelSet::~CReapplyConceptLabelSet() {
}
CConceptSetFlags* CReapplyConceptLabelSet::getConceptFlags() {
return &mConceptFlags;
}
CConceptSetSignature* CReapplyConceptLabelSet::getConceptSignature() {
return &mConceptSignature;
}
CConceptSetStructure* CReapplyConceptLabelSet::getConceptStructure() {
return &mConceptStructure;
}
cint64 CReapplyConceptLabelSet::getConceptSignatureValue() {
return mConceptSignature.getSignatureValue();
}
CReapplyConceptLabelSet* CReapplyConceptLabelSet::initConceptLabelSet(CReapplyConceptLabelSet* prevConceptLabelSet) {
if (prevConceptLabelSet) {
mConceptDesLinker = prevConceptLabelSet->mConceptDesLinker;
mPrevConceptDesLinker = mConceptDesLinker;
mConceptCount = prevConceptLabelSet->mConceptCount;
if (!prevConceptLabelSet->mAdditionalConceptDesDepMap && prevConceptLabelSet->mConceptDesDepMap.size() <= 50 || prevConceptLabelSet->mAdditionalConceptDesDepMap && prevConceptLabelSet->mConceptDesDepMap.size()*10 < prevConceptLabelSet->mAdditionalConceptDesDepMap->size()) {
mConceptDesDepMap = prevConceptLabelSet->mConceptDesDepMap;
mAdditionalConceptDesDepMap = prevConceptLabelSet->mAdditionalConceptDesDepMap;
} else {
mConceptDesDepMap.clear();
if (prevConceptLabelSet->mAdditionalConceptDesDepMap) {
mAdditionalConceptDesDepMap = CObjectParameterizingAllocator< CPROCESSMAP,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getMemoryAllocationManager(),mProcessContext);
*mAdditionalConceptDesDepMap = *prevConceptLabelSet->mAdditionalConceptDesDepMap;
for (CPROCESSMAP::const_iterator it = prevConceptLabelSet->mConceptDesDepMap.constBegin(), itEnd = prevConceptLabelSet->mConceptDesDepMap.constEnd(); it != itEnd; ++it) {
cint64 conTag = it.key();
const CConceptDescriptorDependencyReapplyData& conData = it.value();
(*mAdditionalConceptDesDepMap)[conTag] = conData;
}
} else {
mAdditionalConceptDesDepMap = &prevConceptLabelSet->mConceptDesDepMap;
}
}
mConceptFlags = prevConceptLabelSet->mConceptFlags;
mConceptSignature = prevConceptLabelSet->mConceptSignature;
mCoreConDesLinker = prevConceptLabelSet->mCoreConDesLinker;
mConceptStructure = prevConceptLabelSet->mConceptStructure;
} else {
mConceptDesDepMap.clear();
mAdditionalConceptDesDepMap = nullptr;
mConceptDesLinker = nullptr;
mPrevConceptDesLinker = nullptr;
mCoreConDesLinker = nullptr;
mConceptCount = 0;
mConceptFlags.reset();
mConceptSignature.reset();
mConceptStructure.reset();
}
return this;
}
CCoreConceptDescriptor* CReapplyConceptLabelSet::getCoreConceptDescriptorLinker() {
return mCoreConDesLinker;
}
CReapplyConceptLabelSet* CReapplyConceptLabelSet::addCoreConceptDescriptor(CCoreConceptDescriptor* coreConDes) {
mCoreConDesLinker = coreConDes->append(mCoreConDesLinker);
return this;
}
bool CReapplyConceptLabelSet::hasConceptDescriptor(CConceptDescriptor* conceptDescriptor) {
return hasConcept(conceptDescriptor->getConcept(),conceptDescriptor->getNegation());
}
bool CReapplyConceptLabelSet::containsConceptDescriptor(CConceptDescriptor* conceptDescriptor) {
return hasConceptDescriptor(conceptDescriptor);
}
bool CReapplyConceptLabelSet::hasConcept(CConcept* concept, bool negated) {
if (!mConceptFlags.containsConceptFlags(concept, negated)) {
return false;
}
cint64 conTag = concept->getConceptTag();
CConceptDescriptorDependencyReapplyData* conDesDepData = nullptr;
bool isContained = mConceptDesDepMap.tryGetValuePointer(conTag,conDesDepData);
if (!conDesDepData && mAdditionalConceptDesDepMap) {
isContained = mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,conDesDepData);
}
return isContained && conDesDepData->mConceptDescriptor && conDesDepData->mConceptDescriptor->isNegated() == negated;
}
bool CReapplyConceptLabelSet::hasConcept(CConcept* concept, bool* containsNegated) {
if (!mConceptFlags.containsConceptFlags(concept)) {
return false;
}
cint64 conTag = concept->getConceptTag();
CConceptDescriptorDependencyReapplyData* conDesDepData = nullptr;
bool isContained = mConceptDesDepMap.tryGetValuePointer(conTag,conDesDepData);
if (!conDesDepData && mAdditionalConceptDesDepMap) {
isContained = mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,conDesDepData);
}
if (isContained && containsNegated) {
*containsNegated = conDesDepData->mConceptDescriptor && conDesDepData->mConceptDescriptor->isNegated();
}
return isContained && conDesDepData->mConceptDescriptor;
}
bool CReapplyConceptLabelSet::containsConcept(CConcept* concept, bool* containsNegated) {
return hasConcept(concept,containsNegated);
}
bool CReapplyConceptLabelSet::containsConcept(CConcept* concept, bool negated) {
return hasConcept(concept,negated);
}
bool CReapplyConceptLabelSet::getConceptDescriptor(CConcept* concept, CConceptDescriptor*& conDes, CDependencyTrackPoint*& depTrackPoint) {
return getConceptDescriptor(concept->getConceptTag(),conDes,depTrackPoint);
}
bool CReapplyConceptLabelSet::getConceptDescriptor(cint64 conTag, CConceptDescriptor*& conDes, CDependencyTrackPoint*& depTrackPoint) {
CConceptDescriptorDependencyReapplyData* conDesDepData = nullptr;
bool contained = mConceptDesDepMap.tryGetValuePointer(conTag,conDesDepData);
if (!conDesDepData && mAdditionalConceptDesDepMap) {
contained = mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,conDesDepData);
}
if (contained) {
conDes = conDesDepData->mConceptDescriptor;
if (conDes) {
depTrackPoint = conDes->getDependencyTrackPoint();
} else {
depTrackPoint = nullptr;
}
contained &= conDes != nullptr;
}
return contained;
}
bool CReapplyConceptLabelSet::insertConceptIgnoreClash(CConceptDescriptor* conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CCondensedReapplyQueueIterator* reapplyQueueIt) {
cint64 conTag = conceptDescriptor->getConceptTag();
CConceptDescriptorDependencyReapplyData& conDesDepData = mConceptDesDepMap[conTag];
if (mAdditionalConceptDesDepMap && !conDesDepData.mConceptDescriptor && conDesDepData.mPosNegReapplyQueue.isEmpty()) {
const CConceptDescriptorDependencyReapplyData& addConDesDepData = mAdditionalConceptDesDepMap->value(conTag);
conDesDepData = addConDesDepData;
}
conDesDepData.mConceptDescriptor = conceptDescriptor;
++mConceptCount;
mConceptSignature.addConceptSignature(conceptDescriptor);
mConceptFlags.addConceptFlags(conceptDescriptor);
mConceptStructure.addedConcept(conceptDescriptor);
mConceptDesLinker = conceptDescriptor->append(mConceptDesLinker);
if (reapplyQueueIt) {
*reapplyQueueIt = conDesDepData.mPosNegReapplyQueue.getIterator(conceptDescriptor->isNegated(),true);
}
return true;
}
bool CReapplyConceptLabelSet::insertConceptGetClash(CConceptDescriptor* conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CCondensedReapplyQueueIterator* reapplyQueueIt, CConceptDescriptor** clashedConDes, CDependencyTrackPoint** clashedDepTrackPoint) {
cint64 conTag = conceptDescriptor->getConceptTag();
bool containsAlready = false;
bool containFromAdditionMap = false;
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
mConceptDesDepMap.tryInsert(conTag,CConceptDescriptorDependencyReapplyData(conceptDescriptor),&containsAlready,&containedConDesDepData);
if (!containsAlready && mAdditionalConceptDesDepMap) {
const CConceptDescriptorDependencyReapplyData& addConDesDepData = mAdditionalConceptDesDepMap->value(conTag);
if (addConDesDepData.mConceptDescriptor || !addConDesDepData.mPosNegReapplyQueue.isEmpty()) {
*containedConDesDepData = addConDesDepData;
containsAlready = true;
containFromAdditionMap = true;
}
}
if (containedConDesDepData->mConceptDescriptor == nullptr) {
containedConDesDepData->mConceptDescriptor = conceptDescriptor;
containsAlready = false;
}
if (containsAlready) {
CConceptDescriptor* containsConDes = containedConDesDepData->mConceptDescriptor;
if (containsConDes->isNegated() != conceptDescriptor->isNegated()) {
if (clashedConDes) {
*clashedConDes = containsConDes;
}
if (clashedDepTrackPoint) {
*clashedDepTrackPoint = containsConDes->getDependencyTrackPoint();
}
}
return true;
} else {
++mConceptCount;
mConceptFlags.addConceptFlags(conceptDescriptor);
mConceptSignature.addConceptSignature(conceptDescriptor);
mConceptStructure.addedConcept(conceptDescriptor);
mConceptDesLinker = conceptDescriptor->append(mConceptDesLinker);
if (reapplyQueueIt) {
*reapplyQueueIt = containedConDesDepData->mPosNegReapplyQueue.getIterator(conceptDescriptor->isNegated(),true);
//if (conceptDescriptor->isNegated()) {
// *reapplyQueueIt = containedConDesDepData->mNegReapplyQueue.getIterator(true);
//} else {
// *reapplyQueueIt = containedConDesDepData->mPosReapplyQueue.getIterator(true);
//}
}
return false;
}
}
CClashedConceptDescriptor* CReapplyConceptLabelSet::insertConceptReturnClash(CConceptDescriptor* conceptDescriptor, CDependencyTrackPoint* depTrackPoint, bool* hasContained, CCondensedReapplyQueueIterator* reapplyQueueIt) {
cint64 conTag = conceptDescriptor->getConceptTag();
bool containsAlready = false;
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
mConceptDesDepMap.tryInsert(conTag,CConceptDescriptorDependencyReapplyData(conceptDescriptor),&containsAlready,&containedConDesDepData);
if (!containsAlready && mAdditionalConceptDesDepMap) {
const CConceptDescriptorDependencyReapplyData& addConDesDepData = mAdditionalConceptDesDepMap->value(conTag);
if (addConDesDepData.mConceptDescriptor || !addConDesDepData.mPosNegReapplyQueue.isEmpty()) {
*containedConDesDepData = addConDesDepData;
containsAlready = true;
}
}
if (containedConDesDepData->mConceptDescriptor == nullptr) {
containedConDesDepData->mConceptDescriptor = conceptDescriptor;
containsAlready = false;
}
if (containsAlready) {
if (hasContained) {
*hasContained = true;
}
CConceptDescriptor* containsConDes = containedConDesDepData->mConceptDescriptor;
if (containsConDes->isNegated() != conceptDescriptor->isNegated()) {
CDependencyTrackPoint* containsDepTrackPoint = containsConDes->getDependencyTrackPoint();
// create clash
CClashedConceptDescriptor* clashDes1 = CObjectAllocator::allocateAndConstruct(CContext::getMemoryAllocationManager(mProcessContext));
clashDes1->initClashedConceptDescriptor(conceptDescriptor,depTrackPoint,0);
CClashedConceptDescriptor* clashDes2 = CObjectAllocator::allocateAndConstruct(CContext::getMemoryAllocationManager(mProcessContext));
clashDes2->initClashedConceptDescriptor(containsConDes,containsDepTrackPoint,0);
clashDes1->append(clashDes2);
return clashDes1;
}
} else {
if (hasContained) {
*hasContained = false;
}
++mConceptCount;
mConceptFlags.addConceptFlags(conceptDescriptor);
mConceptSignature.addConceptSignature(conceptDescriptor);
mConceptStructure.addedConcept(conceptDescriptor);
mConceptDesLinker = conceptDescriptor->append(mConceptDesLinker);
if (reapplyQueueIt) {
*reapplyQueueIt = containedConDesDepData->mPosNegReapplyQueue.getIterator(conceptDescriptor->isNegated(),true);
//if (conceptDescriptor->isNegated()) {
// *reapplyQueueIt = containedConDesDepData->mNegReapplyQueue.getIterator(true);
//} else {
// *reapplyQueueIt = containedConDesDepData->mPosReapplyQueue.getIterator(true);
//}
}
}
return nullptr;
}
bool CReapplyConceptLabelSet::insertConceptThrowClashReturnContained(CConceptDescriptor* conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CCondensedReapplyQueueIterator* reapplyQueueIt) {
bool contained = false;
CClashedConceptDescriptor* clash = insertConceptReturnClash(conceptDescriptor,depTrackPoint,&contained,reapplyQueueIt);
if (clash) {
throw clash;
}
return contained;
}
cint64 CReapplyConceptLabelSet::getConceptCount() {
return mConceptCount;
}
CReapplyConceptLabelSetIterator CReapplyConceptLabelSet::getConceptLabelSetIterator(bool getSorted, bool getDependencies, bool getAllStructure) {
if (getSorted || getDependencies || getAllStructure) {
if (mAdditionalConceptDesDepMap) {
return CReapplyConceptLabelSetIterator(mConceptCount,nullptr,mConceptDesDepMap.constBegin(),mConceptDesDepMap.constEnd(),mAdditionalConceptDesDepMap->constBegin(),mAdditionalConceptDesDepMap->constEnd(),!getAllStructure);
} else {
return CReapplyConceptLabelSetIterator(mConceptCount,nullptr,mConceptDesDepMap.constBegin(),mConceptDesDepMap.constEnd(),CPROCESSMAP::const_iterator(),CPROCESSMAP::const_iterator(),!getAllStructure);
}
} else {
return CReapplyConceptLabelSetIterator(mConceptCount,mConceptDesLinker,CPROCESSMAP::const_iterator(),CPROCESSMAP::const_iterator(),CPROCESSMAP::const_iterator(),CPROCESSMAP::const_iterator());
}
}
bool CReapplyConceptLabelSet::getConceptDescriptorAndReapplyQueue(CConcept* concept, CConceptDescriptor*& conDes, CDependencyTrackPoint*& depTrackPoint, CCondensedReapplyQueue*& reapplyQueue) {
cint64 conTag = concept->getConceptTag();
return getConceptDescriptorAndReapplyQueue(conTag,conDes,depTrackPoint,reapplyQueue);
}
bool CReapplyConceptLabelSet::getConceptDescriptorAndReapplyQueue(cint64 conTag, CConceptDescriptor*& conDes, CDependencyTrackPoint*& depTrackPoint, CCondensedReapplyQueue*& reapplyQueue) {
CConceptDescriptorDependencyReapplyData* conDesDepData = nullptr;
bool contained = mConceptDesDepMap.tryGetValuePointer(conTag,conDesDepData);
if (!conDesDepData && mAdditionalConceptDesDepMap) {
contained = mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,conDesDepData);
}
if (contained) {
conDes = conDesDepData->mConceptDescriptor;
reapplyQueue = &conDesDepData->mPosNegReapplyQueue;
if (conDes) {
depTrackPoint = conDes->getDependencyTrackPoint();
} else {
depTrackPoint = nullptr;
}
contained = conDes != nullptr;
}
return contained;
}
bool CReapplyConceptLabelSet::getConceptDescriptorOrReapplyQueue(CConcept* concept, CConceptDescriptor*& conDes, CDependencyTrackPoint*& depTrackPoint, CCondensedReapplyQueue*& reapplyQueue) {
cint64 conTag = concept->getConceptTag();
return getConceptDescriptorOrReapplyQueue(conTag,conDes,depTrackPoint,reapplyQueue);
}
bool CReapplyConceptLabelSet::getConceptDescriptorOrReapplyQueue(cint64 conTag, CConceptDescriptor*& conDes, CDependencyTrackPoint*& depTrackPoint, CCondensedReapplyQueue*& reapplyQueue) {
CConceptDescriptorDependencyReapplyData* conDesDepData = nullptr;
bool contained = mConceptDesDepMap.tryGetValuePointer(conTag,conDesDepData);
if (!conDesDepData && mAdditionalConceptDesDepMap) {
contained = mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,conDesDepData);
}
if (contained) {
conDes = conDesDepData->mConceptDescriptor;
reapplyQueue = &conDesDepData->mPosNegReapplyQueue;
if (conDes) {
depTrackPoint = conDes->getDependencyTrackPoint();
} else {
depTrackPoint = nullptr;
}
contained = conDes != nullptr || reapplyQueue != nullptr;
}
return contained;
}
CCondensedReapplyQueue* CReapplyConceptLabelSet::getConceptDescriptorAndReapplyQueue(CConcept*& concept, CConceptDescriptor*& conDes, bool create) {
cint64 conTag = concept->getConceptTag();
if (create) {
bool containsAlready = false;
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
mConceptDesDepMap.tryInsert(conTag,CConceptDescriptorDependencyReapplyData(nullptr),&containsAlready,&containedConDesDepData);
if (!containsAlready && mAdditionalConceptDesDepMap) {
const CConceptDescriptorDependencyReapplyData& addConDesDepData = mAdditionalConceptDesDepMap->value(conTag);
if (addConDesDepData.mConceptDescriptor || !addConDesDepData.mPosNegReapplyQueue.isEmpty()) {
*containedConDesDepData = addConDesDepData;
containsAlready = true;
}
}
conDes = containedConDesDepData->mConceptDescriptor;
return &containedConDesDepData->mPosNegReapplyQueue;
} else {
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
if (mConceptDesDepMap.tryGetValuePointer(conTag,containedConDesDepData)) {
conDes = containedConDesDepData->mConceptDescriptor;
return &containedConDesDepData->mPosNegReapplyQueue;
} else if (mAdditionalConceptDesDepMap && mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,containedConDesDepData)) {
conDes = containedConDesDepData->mConceptDescriptor;
return &containedConDesDepData->mPosNegReapplyQueue;
}
}
return nullptr;
}
CCondensedReapplyQueue* CReapplyConceptLabelSet::getConceptReapplyQueue(cint64 conTag, bool create) {
if (create) {
bool containsAlready = false;
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
mConceptDesDepMap.tryInsert(conTag,CConceptDescriptorDependencyReapplyData(nullptr),&containsAlready,&containedConDesDepData);
if (!containsAlready && mAdditionalConceptDesDepMap) {
const CConceptDescriptorDependencyReapplyData& addConDesDepData = mAdditionalConceptDesDepMap->value(conTag);
if (addConDesDepData.mConceptDescriptor || !addConDesDepData.mPosNegReapplyQueue.isEmpty()) {
*containedConDesDepData = addConDesDepData;
containsAlready = true;
}
}
return &containedConDesDepData->mPosNegReapplyQueue;
//if (conceptNegation) {
// return &containedConDesDepData->mNegReapplyQueue;
//} else {
// return &containedConDesDepData->mPosReapplyQueue;
//}
} else {
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
if (mConceptDesDepMap.tryGetValuePointer(conTag,containedConDesDepData)) {
return &containedConDesDepData->mPosNegReapplyQueue;
//if (conceptNegation) {
// return &containedConDesDepData->mNegReapplyQueue;
//} else {
// return &containedConDesDepData->mPosReapplyQueue;
//}
} else if (mAdditionalConceptDesDepMap && mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,containedConDesDepData)) {
return &containedConDesDepData->mPosNegReapplyQueue;
}
}
return nullptr;
}
CCondensedReapplyQueue* CReapplyConceptLabelSet::getConceptReapplyQueue(CConcept *&concept, bool &conceptNegation, bool create) {
cint64 conTag = concept->getConceptTag();
return getConceptReapplyQueue(conTag,create);
}
bool CReapplyConceptLabelSet::containsConceptReapplyQueue(CConcept *&concept, bool &conceptNegation) {
cint64 conTag = concept->getConceptTag();
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
if (mConceptDesDepMap.tryGetValuePointer(conTag,containedConDesDepData)) {
return !containedConDesDepData->mPosNegReapplyQueue.isEmpty();
//if (conceptNegation) {
// return !containedConDesDepData->mNegReapplyQueue.isEmpty();
//} else {
// return !containedConDesDepData->mPosReapplyQueue.isEmpty();
//}
} else if (mAdditionalConceptDesDepMap && mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,containedConDesDepData)) {
return !containedConDesDepData->mPosNegReapplyQueue.isEmpty();
}
return false;
}
CCondensedReapplyQueueIterator CReapplyConceptLabelSet::getConceptReapplyIterator(CConcept* concept, bool conceptNegation, bool clearDynamicReapplyQueue) {
cint64 conTag = concept->getConceptTag();
CConceptDescriptorDependencyReapplyData* containedConDesDepData = nullptr;
if (mConceptDesDepMap.tryGetValuePointer(conTag,containedConDesDepData)) {
if (!clearDynamicReapplyQueue) {
return containedConDesDepData->mPosNegReapplyQueue.getIterator(conceptNegation, false);
} else {
CConceptDescriptorDependencyReapplyData& conDesDepData = mConceptDesDepMap[conTag];
return conDesDepData.mPosNegReapplyQueue.getIterator(conceptNegation, true);
}
//if (conceptNegation) {
// return containedConDesDepData->mNegReapplyQueue.getIterator(clearDynamicReapplyQueue);
//} else {
// return containedConDesDepData->mPosReapplyQueue.getIterator(clearDynamicReapplyQueue);
//}
} else if (mAdditionalConceptDesDepMap && mAdditionalConceptDesDepMap->tryGetValuePointer(conTag,containedConDesDepData)) {
if (!clearDynamicReapplyQueue) {
return containedConDesDepData->mPosNegReapplyQueue.getIterator(conceptNegation, false);
} else {
if (!containedConDesDepData->mPosNegReapplyQueue.isEmpty()) {
CConceptDescriptorDependencyReapplyData& conDesDepData = mConceptDesDepMap[conTag];
conDesDepData = *containedConDesDepData;
return conDesDepData.mPosNegReapplyQueue.getIterator(conceptNegation, true);
} else {
return containedConDesDepData->mPosNegReapplyQueue.getIterator(conceptNegation, false);
}
}
}
return CCondensedReapplyQueueIterator(nullptr,conceptNegation);
}
CCondensedReapplyQueueIterator CReapplyConceptLabelSet::getConceptReapplyIterator(CConceptDescriptor* conDes, bool clearDynamicReapplyQueue) {
return getConceptReapplyIterator(conDes->getConcept(),conDes->isNegated(),clearDynamicReapplyQueue);
}
CConceptDescriptor* CReapplyConceptLabelSet::getAddingSortedConceptDescriptionLinker() {
return mConceptDesLinker;
}
CConceptDescriptorDependencyReapplyData* CReapplyConceptLabelSet::getConceptDescriptorDependencyReapplyData(cint64 dataTag) {
CConceptDescriptorDependencyReapplyData& conData = mConceptDesDepMap[dataTag];
if (mAdditionalConceptDesDepMap && !conData.mConceptDescriptor && conData.mPosNegReapplyQueue.isEmpty()) {
const CConceptDescriptorDependencyReapplyData& addConDesDepData = mAdditionalConceptDesDepMap->value(dataTag);
conData = addConDesDepData;
}
return &conData;
}
}; // end namespace Process
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude