/*
* 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 "CBackendRepresentativeMemoryCacheReader.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Cache {
CBackendRepresentativeMemoryCacheReader::CBackendRepresentativeMemoryCacheReader() : CLinkerBase(this) {
mCurrentSlot = nullptr;
mFixedOntologyData = nullptr;
mOntologyData = nullptr;
mRecomputationId = 0;
}
CBackendRepresentativeMemoryCacheReader* CBackendRepresentativeMemoryCacheReader::updateSlot(CBackendRepresentativeMemoryCacheSlotItem* updatedSlot) {
CBackendRepresentativeMemoryCacheSlotItem* prevSlot = mUpdatedSlot.fetchAndStoreOrdered(updatedSlot);
if (prevSlot != nullptr) {
prevSlot->decReader();
}
return this;
}
CBackendRepresentativeMemoryCacheReader* CBackendRepresentativeMemoryCacheReader::checkRecomputationIdUsage(cint64 recomputationId) {
mRecomputationId = recomputationId;
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (!mOntologyData && mCurrentSlot) {
mOntologyData = mCurrentSlot->getOntologyData(mOntologyIdentifier);
}
if (mOntologyData) {
if (recomputationId < mOntologyData->getMinimumValidRecomputationId()) {
throw CCalculationErrorProcessingException(CCalculationErrorProcessingException::ECINVALIDRECOMPUATIONID);
}
CBackendRepresentativeMemoryCacheOntologyDataRecomputationReferenceLinker* recRefLinker = mOntologyData->getRecomputationReferenceLinker();
if (recRefLinker) {
recRefLinker->updateUsedRecomputationId(recomputationId);
}
}
return this;
}
CBackendRepresentativeMemoryCacheReader* CBackendRepresentativeMemoryCacheReader::fixOntologyData(CBackendRepresentativeMemoryCacheOntologyData* ontologyData) {
mFixedOntologyData = ontologyData;
mOntologyData = ontologyData;
return this;
}
bool CBackendRepresentativeMemoryCacheReader::hasUpdatedSlotItem() {
return mUpdatedSlot.fetchAndAddRelaxed(0) != nullptr;
}
bool CBackendRepresentativeMemoryCacheReader::switchToUpdatedSlotItem() {
CBackendRepresentativeMemoryCacheSlotItem* updatedSlot = mUpdatedSlot.fetchAndStoreOrdered(nullptr);
if (updatedSlot) {
CBackendRepresentativeMemoryCacheSlotItem* prevSlot = mCurrentSlot;
mCurrentSlot = updatedSlot;
if (prevSlot != nullptr) {
prevSlot->decReader();
}
mOntologyData = nullptr;
if (mCurrentSlot) {
mOntologyData = mCurrentSlot->getOntologyData(mOntologyIdentifier);
}
if (mOntologyData && mRecomputationId != 0) {
CBackendRepresentativeMemoryCacheOntologyDataRecomputationReferenceLinker* recRefLinker = mOntologyData->getRecomputationReferenceLinker();
if (recRefLinker) {
recRefLinker->updateUsedRecomputationId(mRecomputationId);
}
}
return true;
}
return false;
}
CBackendRepresentativeMemoryCacheReader* CBackendRepresentativeMemoryCacheReader::setWorkingOntology(cint64 ontologyIdentifier) {
mOntologyIdentifier = ontologyIdentifier;
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
mOntologyData = nullptr;
if (mCurrentSlot) {
mOntologyData = mCurrentSlot->getOntologyData(mOntologyIdentifier);
}
if (mFixedOntologyData) {
mOntologyData = mFixedOntologyData;
}
return this;
}
CBackendRepresentativeMemoryCacheReader* CBackendRepresentativeMemoryCacheReader::setWorkingOntology(CConcreteOntology* ontology) {
return setWorkingOntology(ontology->getOntologyID());
}
bool CBackendRepresentativeMemoryCacheReader::hasSameIndividualsMergings() {
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mOntologyData) {
return mOntologyData->hasSameIndividualsMergings();
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasCacheEntry(cint64 labelType, cint64 signature) {
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mOntologyData) {
CCACHINGHASH* sigItemHash = mOntologyData->getSignatureLabelItemHash(labelType);
if (sigItemHash) {
return sigItemHash->contains(signature);
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitLabelCacheEntries(cint64 labelType, function visitFunc) {
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
bool continueVisiting = true;
bool visited = false;
if (mOntologyData) {
CCACHINGHASH* sigItemHash = mOntologyData->getSignatureLabelItemHash(labelType);
if (sigItemHash) {
for (CCACHINGHASH::const_iterator sigHashIt = sigItemHash->constBegin(), sigHashItEnd = sigItemHash->constEnd(); sigHashIt != sigHashItEnd && continueVisiting; ++sigHashIt) {
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem sigResolveCacheItem = sigHashIt.value();
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResolveCacheItem.getLabelItems(); itemIt && continueVisiting; itemIt = itemIt->getNext()) {
continueVisiting = visitFunc(itemIt);
visited = true;
}
}
}
}
return visited;
}
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* CBackendRepresentativeMemoryCacheReader::getLabelCacheEntry(cint64 labelType, cint64 signature) {
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* entry = &mEmptySigResCacheItem;
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mOntologyData) {
CCACHINGHASH* sigItemHash = mOntologyData->getSignatureLabelItemHash(labelType);
if (sigItemHash && sigItemHash->contains(signature)) {
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem& item = (*sigItemHash)[signature];
entry = &item;
}
}
return entry;
}
CBackendRepresentativeMemoryCacheIndividualAssociationData* CBackendRepresentativeMemoryCacheReader::getIndividualAssociationData(CIndividual* individual) {
CBackendRepresentativeMemoryCacheIndividualAssociationData* assData = nullptr;
if (!assData) {
assData = getIndividualAssociationData(individual->getIndividualID());
}
return assData;
}
CBackendRepresentativeMemoryCacheIndividualAssociationData* CBackendRepresentativeMemoryCacheReader::getIndividualAssociationData(cint64 indiId) {
CBackendRepresentativeMemoryCacheIndividualAssociationData* assData = nullptr;
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mOntologyData) {
cint64 indiIdAssoDataVectorSize = mOntologyData->getIndividualIdAssoiationDataVectorSize();
CBackendRepresentativeMemoryCacheIndividualAssociationData** indiIdAssoDataVector = mOntologyData->getIndividualIdAssoiationDataVector();
if (mOntologyData->isBasicPrecomputationMode()) {
indiIdAssoDataVectorSize = mOntologyData->getBasicPrecomputationIndividualIdAssoiationDataVectorSize();
indiIdAssoDataVector = mOntologyData->getBasicPrecomputationIndividualIdAssoiationDataVector();
}
if (indiIdAssoDataVector && indiId < indiIdAssoDataVectorSize) {
assData = indiIdAssoDataVector[indiId];
}
//CCACHINGHASH* indiIdAssoDataHash = mOntologyData->getIndividualIdAssociationDataHash();
//if (indiIdAssoDataHash) {
// assData = indiIdAssoDataHash->value(indiId, nullptr);
//}
//TODO: create copy of data
}
return assData;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getIndividualAssociatedCacheLabelItem(cint64 indiId, cint64 labelType) {
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mOntologyData) {
CBackendRepresentativeMemoryCacheIndividualAssociationData* assData = nullptr;
cint64 indiIdAssoDataVectorSize = mOntologyData->getIndividualIdAssoiationDataVectorSize();
CBackendRepresentativeMemoryCacheIndividualAssociationData** indiIdAssoDataVector = mOntologyData->getIndividualIdAssoiationDataVector();
if (mOntologyData->isBasicPrecomputationMode()) {
indiIdAssoDataVectorSize = mOntologyData->getBasicPrecomputationIndividualIdAssoiationDataVectorSize();
indiIdAssoDataVector = mOntologyData->getBasicPrecomputationIndividualIdAssoiationDataVector();
}
if (indiIdAssoDataVector && indiId < indiIdAssoDataVectorSize) {
assData = indiIdAssoDataVector[indiId];
}
if (assData) {
return assData->getLabelCacheEntry(labelType);
}
}
return nullptr;
}
CBackendRepresentativeMemoryCacheNominalIndividualIndirectConnectionData* CBackendRepresentativeMemoryCacheReader::getNominalIndirectConnectionData(cint64 indiId) {
CBackendRepresentativeMemoryCacheNominalIndividualIndirectConnectionData* nomConnData = nullptr;
if (hasUpdatedSlotItem()) {
switchToUpdatedSlotItem();
}
if (mOntologyData) {
CCACHINGHASH* nominaIIndividualdIndirectConnectionDataHash = mOntologyData->getNominaIIndividualdIndirectConnectionDataHash();
if (nominaIIndividualdIndirectConnectionDataHash) {
nomConnData = nominaIIndividualdIndirectConnectionDataHash->value(indiId);
}
//TODO: create copy of data
}
return nomConnData;
}
const CCacheValue CBackendRepresentativeMemoryCacheReader::getCacheValue(cint64 indiId, bool negation) {
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHE_VALUE_INDIVIDUAL_ID;
if (negation) {
indiId = -indiId;
cacheValueIdentifier = CCacheValue::CACHE_VALUE_NEGATED_INDIVIDUAL_ID;
}
CCacheValue cacheValue;
cacheValue.initCacheValue(indiId, 0, cacheValueIdentifier);
return cacheValue;
}
const CCacheValue CBackendRepresentativeMemoryCacheReader::getCacheValue(CConcept* concept, bool negation, bool deterministic) {
cint64 conTag = concept->getConceptTag();
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDCONCEPT;
if (negation) {
conTag = -conTag;
if (deterministic) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT;
} else {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NEGATED_CONCEPT;
}
} else if (!deterministic) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_CONCEPT;
}
CCacheValue cacheValue;
cacheValue.initCacheValue(conTag, (cint64)concept, cacheValueIdentifier);
return cacheValue;
}
const CCacheValue CBackendRepresentativeMemoryCacheReader::getCacheValue(CRole* role) {
cint64 roleTag = role->getRoleTag();
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDROLE;
CCacheValue cacheValue;
cacheValue.initCacheValue(roleTag,(cint64)role,cacheValueIdentifier);
return cacheValue;
}
bool CBackendRepresentativeMemoryCacheReader::isCacheValueRoleInverse(const CCacheValue& cacheValue) {
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = cacheValue.getCacheValueIdentifier();
return cacheValueIdentifier == CCacheValue::CACHEVALTAGANDINVERSEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGANDINVERSEDASSERTEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGANDINVERSED_NOMINAL_CONNECTED_ROLE
|| cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
}
bool CBackendRepresentativeMemoryCacheReader::isCacheValueRoleNondeterministic(const CCacheValue& cacheValue) {
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = cacheValue.getCacheValueIdentifier();
return cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ASSERTEDROLE
|| cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NOMINAL_CONNECTED_ROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
}
bool CBackendRepresentativeMemoryCacheReader::isCacheValueRoleNominal(const CCacheValue& cacheValue) {
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = cacheValue.getCacheValueIdentifier();
return cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NOMINAL_CONNECTED_ROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGANDINVERSED_NOMINAL_CONNECTED_ROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NOMINAL_CONNECTED_ROLE
|| cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
}
bool CBackendRepresentativeMemoryCacheReader::isCacheValueRoleAssertion(const CCacheValue& cacheValue) {
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = cacheValue.getCacheValueIdentifier();
return cacheValueIdentifier == CCacheValue::CACHEVALTAGANDASSERTEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGANDINVERSEDASSERTEDROLE || cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ASSERTEDROLE
|| cacheValueIdentifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE;
}
const CCacheValue CBackendRepresentativeMemoryCacheReader::getCacheValue(CRole* role, bool inversed, bool assertionLinkBase, bool nominalConnected, bool nondeterministc) {
cint64 roleTag = role->getRoleTag();
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHEVALTAGANDROLE;
if (inversed) {
roleTag = -roleTag;
if (assertionLinkBase) {
if (!nondeterministc) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGANDINVERSEDASSERTEDROLE;
} else {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE;
}
} else if (nominalConnected) {
if (!nondeterministc) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGANDINVERSED_NOMINAL_CONNECTED_ROLE;
} else {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
}
} else {
if (!nondeterministc) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGANDINVERSEDROLE;
} else {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDROLE;
}
}
} else {
if (assertionLinkBase) {
if (!nondeterministc) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGANDASSERTEDROLE;
} else {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ASSERTEDROLE;
}
} else if (nominalConnected) {
if (!nondeterministc) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NOMINAL_CONNECTED_ROLE;
} else {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NOMINAL_CONNECTED_ROLE;
}
} else if (nondeterministc) {
cacheValueIdentifier = CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ROLE;
}
}
CCacheValue cacheValue;
cacheValue.initCacheValue(roleTag, (cint64)role, cacheValueIdentifier);
return cacheValue;
}
bool CBackendRepresentativeMemoryCacheReader::visitLabelsOfAssociatedNeigbourRoleSetCombinationLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetCompinationLabel, function visitFunc) {
if (neighbourRoleSetCompinationLabel) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = neighbourRoleSetCompinationLabel->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSet = (CBackendRepresentativeMemoryLabelCacheItem*)cacheValue.getIdentification();
continueVisiting = visitFunc(neighbourRoleSet);
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitRolesOfAssociatedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, function visitFunc) {
if (neighbourRoleSetLabel) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = neighbourRoleSetLabel->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
CRole* role = (CRole*)cacheValue.getIdentification();
CCacheValue::CACHEVALUEIDENTIFIER identifier = cacheValue.getCacheValueIdentifier();
bool roleInversed = identifier == CCacheValue::CACHEVALTAGANDINVERSEDROLE || identifier == CCacheValue::CACHEVALTAGANDINVERSEDASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGANDINVERSED_NOMINAL_CONNECTED_ROLE ||
identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
bool assertionLinkBase = identifier == CCacheValue::CACHEVALTAGANDASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGANDINVERSEDASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE;
bool nominalConnected = identifier == CCacheValue::CACHEVALTAGAND_NOMINAL_CONNECTED_ROLE || identifier == CCacheValue::CACHEVALTAGANDINVERSED_NOMINAL_CONNECTED_ROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NOMINAL_CONNECTED_ROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
bool nondeterministc = identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ASSERTEDROLE ||
identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NOMINAL_CONNECTED_ROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
continueVisiting = visitFunc(role, roleInversed, assertionLinkBase, nominalConnected, nondeterministc);
}
return true;
}
}
return false;
}
cint64 CBackendRepresentativeMemoryCacheReader::getNeighbourCountForArrayPos(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, cint64 pos) {
cint64 count = 0;
CBackendRepresentativeMemoryCacheIndividualRoleSetNeighbourArray* neighbourArray = assData->getRoleSetNeighbourArray();
CBackendRepresentativeMemoryLabelCacheItem* neighbourCombLabelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL);
if (neighbourCombLabelItem && neighbourArray) {
count += neighbourArray->at(pos).getIndividualCount();
}
return count;
}
cint64 CBackendRepresentativeMemoryCacheReader::getNeighbourCountForRole(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CRole* role) {
cint64 count = 0;
CBackendRepresentativeMemoryCacheIndividualRoleSetNeighbourArray* neighbourArray = assData->getRoleSetNeighbourArray();
CBackendRepresentativeMemoryLabelCacheItem* neighbourCombLabelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL);
if (neighbourCombLabelItem && neighbourArray) {
CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData* extensionData = (CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData*)neighbourCombLabelItem->getExtensionData(CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData::TAG_RESOLVING_HASH);
if (extensionData) {
for (CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingDataLinker* linkerIt = extensionData->getTagLabelResolvingDataLinker(role->getRoleTag()); linkerIt; linkerIt = linkerIt->getNext()) {
cint64 index = linkerIt->getIndex();
count += neighbourArray->at(index).getIndividualCount();
}
}
}
return count;
}
bool CBackendRepresentativeMemoryCacheReader::visitNeighbourIndividualIdsForNeighbourArrayIdFromCursor(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, cint64 arrayId, function visitFunc, bool visitOnlyDeterministicNeighbours, cint64 cursor) {
CBackendRepresentativeMemoryCacheIndividualRoleSetNeighbourArray* neighbourArray = assData->getRoleSetNeighbourArray();
CBackendRepresentativeMemoryLabelCacheItem* neighbourCombLabelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL);
if (neighbourCombLabelItem && neighbourArray) {
CBackendRepresentativeMemoryLabelCacheItem* neighbourLabel = neighbourArray->getIndexData()->getNeighbourRoleSetLabel(arrayId);
bool continueVisiting = true;
neighbourArray->at(arrayId).visitNeighbourIndividualIdsFromCursor([&](cint64 neighbourIndiId, cint64 cursor)->bool {
continueVisiting = visitFunc(neighbourIndiId, neighbourLabel, neighbourLabel->hasNondeterministicElements(), cursor);
return continueVisiting;
}, cursor);
return true;
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitNeighbourIndividualIdsForRole(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CRole* role, function visitFunc, bool visitOnlyDeterministicNeighbours) {
CBackendRepresentativeMemoryCacheIndividualRoleSetNeighbourArray* neighbourArray = assData->getRoleSetNeighbourArray();
CBackendRepresentativeMemoryLabelCacheItem* neighbourCombLabelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL);
if (neighbourCombLabelItem && neighbourArray) {
CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData* extensionData = (CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData*)neighbourCombLabelItem->getExtensionData(CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData::TAG_RESOLVING_HASH);
if (extensionData) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingDataLinker* linkerIt = extensionData->getTagLabelResolvingDataLinker(role->getRoleTag()); linkerIt && continueVisiting; linkerIt = linkerIt->getNext()) {
cint64 index = linkerIt->getIndex();
if (!visitOnlyDeterministicNeighbours || linkerIt->isDeterministic()) {
neighbourArray->at(index).visitNeighbourIndividualIds([&](cint64 neighbourIndiId)->bool {
continueVisiting = visitFunc(neighbourIndiId, linkerIt->getLabelCacheItem(), !linkerIt->isDeterministic());
return continueVisiting;
});
}
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitNeighbourArrayIdsForRole(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CRole* role, function visitFunc, bool visitOnlyDeterministicNeighbours) {
CBackendRepresentativeMemoryCacheIndividualRoleSetNeighbourArray* neighbourArray = assData->getRoleSetNeighbourArray();
CBackendRepresentativeMemoryLabelCacheItem* neighbourCombLabelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL);
if (neighbourCombLabelItem && neighbourArray) {
CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData* extensionData = (CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData*)neighbourCombLabelItem->getExtensionData(CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingExtensionData::TAG_RESOLVING_HASH);
if (extensionData) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelCacheItemTagLabelResolvingDataLinker* linkerIt = extensionData->getTagLabelResolvingDataLinker(role->getRoleTag()); linkerIt && continueVisiting; linkerIt = linkerIt->getNext()) {
cint64 index = linkerIt->getIndex();
if (!visitOnlyDeterministicNeighbours || linkerIt->isDeterministic()) {
continueVisiting = visitFunc(index, linkerIt->getLabelCacheItem(), !linkerIt->isDeterministic());
}
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasRoleInAssociatedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, CRole* role, bool inversed, bool assertionLinkBase, bool nominalLinkBase, bool nondeterministic) {
if (neighbourRoleSetLabel) {
CCACHINGHASH* labelValueHash = neighbourRoleSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = role->getRoleTag();
if (inversed) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker && getCacheValue(role, inversed, assertionLinkBase, nominalLinkBase, nondeterministic) == labelLinker->getCacheValue()) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasRoleInAssociatedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, CRole* role, bool inversed) {
if (neighbourRoleSetLabel) {
CCACHINGHASH* labelValueHash = neighbourRoleSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = role->getRoleTag();
if (inversed) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasIndividualIdsInAssociatedIndividualSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* indiSetLabel, cint64 indiId) {
if (indiSetLabel) {
CCACHINGHASH* labelValueHash = indiSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(indiId);
if (labelLinker) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasRoleInAssociatedCompinationRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* compinationRoleSetLabel, CRole* role, bool inversed) {
if (compinationRoleSetLabel) {
CCACHINGHASH* labelValueHash = compinationRoleSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = role->getRoleTag();
if (inversed) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasRoleInAssociatedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, CRole* role, bool inversed, bool nondeterministic) {
if (neighbourRoleSetLabel) {
CCACHINGHASH* labelValueHash = neighbourRoleSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = role->getRoleTag();
if (inversed) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker) {
CCacheValue::CACHEVALUEIDENTIFIER identifier = labelLinker->getCacheValue().getCacheValueIdentifier();
bool nondeterministcCached = identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_ASSERTEDROLE ||
identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSEDASSERTEDROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NOMINAL_CONNECTED_ROLE || identifier == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_INVERSED_NOMINAL_CONNECTED_ROLE;
return nondeterministcCached == nondeterministic;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReaderhasRoleInAssociatedCombinedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, CRole* role, bool inversed) {
if (neighbourRoleSetLabel) {
CCACHINGHASH* labelValueHash = neighbourRoleSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = role->getRoleTag();
if (inversed) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitRolesOfAssociatedCompinationRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* combinationRoleSetLabel, function visitFunc) {
if (combinationRoleSetLabel) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = combinationRoleSetLabel->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
CRole* role = (CRole*)cacheValue.getIdentification();
bool roleInversed = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDINVERSEDROLE;
continueVisiting = visitFunc(role, roleInversed);
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitRolesOfAssociatedCombinedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, function visitFunc) {
if (neighbourRoleSetLabel) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = neighbourRoleSetLabel->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
CRole* role = (CRole*)cacheValue.getIdentification();
bool roleInversed = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDINVERSEDROLE || cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDINVERSEDASSERTEDROLE || cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDINVERSED_NOMINAL_CONNECTED_ROLE;
continueVisiting = visitFunc(role, roleInversed);
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasRoleInAssociatedCombinedNeigbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel, CRole* role, bool inversed) {
if (neighbourRoleSetLabel) {
CCACHINGHASH* labelValueHash = neighbourRoleSetLabel->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = role->getRoleTag();
if (inversed) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker && getCacheValue(role, inversed) == labelLinker->getCacheValue()) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasRoleToNeigbourInAssociatedNeighbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, cint64 neighbourIndiId, CRole* role, bool inversed) {
CBackendRepresentativeMemoryCacheIndividualNeighbourRoleSetHash* neighbourRoleSetHash = assData->getNeighbourRoleSetHash();
if (neighbourRoleSetHash) {
CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel = neighbourRoleSetHash->getNeighbourRoleSetLabel(neighbourIndiId);
if (neighbourRoleSetLabel) {
return hasRoleInAssociatedNeigbourRoleSetLabel(assData, neighbourRoleSetLabel, role, inversed);
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitRolesToNeigbourInAssociatedNeighbourRoleSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, cint64 neighbourIndiId, function visitFunc) {
if (assData) {
CBackendRepresentativeMemoryCacheIndividualNeighbourRoleSetHash* neighbourRoleSetHash = assData->getNeighbourRoleSetHash();
if (neighbourRoleSetHash) {
CBackendRepresentativeMemoryLabelCacheItem* neighbourRoleSetLabel = neighbourRoleSetHash->getNeighbourRoleSetLabel(neighbourIndiId);
if (neighbourRoleSetLabel) {
return visitRolesOfAssociatedNeigbourRoleSetLabel(assData, neighbourRoleSetLabel, visitFunc);
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitNominalIndirectlyConnectedIndividualIds(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryCacheNominalIndividualIndirectConnectionData* nomConnData, function visitFunc) {
if (nomConnData) {
CXLinker* linker = nomConnData->getIndirectlyConnectedIndividualIdLinker();
if (linker) {
bool continueVisiting = true;
for (CXLinker* connIndiIdIt = linker; connIndiIdIt && continueVisiting; connIndiIdIt = connIndiIdIt->getNext()) {
cint64 indirectlyConnectedIndiId = connIndiIdIt->getData();
// TODO: these individuals are only candidates, check whether they are still valid
continueVisiting = visitFunc(indirectlyConnectedIndiId);
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitIndividualIdsOfAssociatedIndividualSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* indiSetLabel, function visitFunc) {
if (indiSetLabel) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = indiSetLabel->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
cint64 indiId = cacheValue.getTag();
continueVisiting = visitFunc(indiId);
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitConceptsOfAssociatedDeterministicConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, function visitFunc) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = assData->getDeterministicConceptSetLabelCacheEntry();
return visitConceptsOfAssociatedConceptSetLabel(assData, labelItem, visitFunc);
}
bool CBackendRepresentativeMemoryCacheReader::hasConceptInAssociatedDeterministicConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CConcept* concept, bool negation) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = assData->getDeterministicConceptSetLabelCacheEntry();
return hasConceptInAssociatedConceptSetLabel(assData, labelItem, concept, negation);
}
bool CBackendRepresentativeMemoryCacheReader::visitConceptsOfAssociatedNonDeterministicConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, function visitFunc) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NONDETERMINISTIC_CONCEPT_SET_LABEL);
return visitConceptsOfAssociatedConceptSetLabel(assData, labelItem, visitFunc);
}
bool CBackendRepresentativeMemoryCacheReader::hasConceptInAssociatedNonDeterministicConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CConcept* concept, bool negation) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = assData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NONDETERMINISTIC_CONCEPT_SET_LABEL);
return hasConceptInAssociatedConceptSetLabel(assData, labelItem, concept, negation);
}
bool CBackendRepresentativeMemoryCacheReader::visitConceptsOfAssociatedConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* labelItem, function visitFunc) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = labelItem->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
CConcept* concept = (CConcept*)cacheValue.getIdentification();
bool conceptNegation = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT;
continueVisiting = visitFunc(concept, conceptNegation);
}
return true;
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasConceptInAssociatedConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* labelItem, CConcept* concept, bool negation) {
CCACHINGHASH* labelValueHash = labelItem->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = concept->getConceptTag();
if (negation) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker && getCacheValue(concept, negation) == labelLinker->getCacheValue()) {
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitLabelItemIndividualIdAssociations(CBackendRepresentativeMemoryLabelCacheItem* labelItem, function visitFunc, bool ascending, bool visitBaseIndividual, bool visitSameMergedIndividuals) {
CBackendRepresentativeMemoryLabelCacheItemIndividualAssociationMapExtensionData* indiAssMapExtensionData = (CBackendRepresentativeMemoryLabelCacheItemIndividualAssociationMapExtensionData*)labelItem->getExtensionData(CBackendRepresentativeMemoryLabelCacheItemIndividualAssociationMapExtensionData::INDIVIDUAL_ASSOCIATION_MAP);
if (indiAssMapExtensionData) {
return indiAssMapExtensionData->visitIndividualIdAssociations(visitFunc, ascending, visitBaseIndividual, visitSameMergedIndividuals);
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::visitConceptsOfAssociatedFullConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* labelItem, function visitFunc, bool visitDeterministicConcepts, bool visitNonDeterministicConcepts) {
return visitConceptsOfFullConceptSetLabel(labelItem, visitFunc, visitDeterministicConcepts, visitNonDeterministicConcepts);
}
bool CBackendRepresentativeMemoryCacheReader::visitConceptsOfFullConceptSetLabel(CBackendRepresentativeMemoryLabelCacheItem* labelItem, function visitFunc, bool visitDeterministicConcepts, bool visitNonDeterministicConcepts) {
if (labelItem) {
CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinker = labelItem->getCacheValueLinker();
if (lablelValueLinker) {
bool continueVisiting = true;
for (CBackendRepresentativeMemoryLabelValueLinker* lablelValueLinkerIt = lablelValueLinker; lablelValueLinkerIt && continueVisiting; lablelValueLinkerIt = lablelValueLinkerIt->getNext()) {
const CCacheValue& cacheValue = lablelValueLinkerIt->getCacheValue();
CConcept* concept = (CConcept*)cacheValue.getIdentification();
bool conceptNegation = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT || cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGAND_NONDETERMINISTIC_NEGATED_CONCEPT;
bool deterministic = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT || cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDCONCEPT;
if (deterministic && visitDeterministicConcepts || !deterministic && visitNonDeterministicConcepts) {
continueVisiting = visitFunc(concept, conceptNegation, deterministic);
}
}
return true;
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::getConceptOccurrenceInAssociatedFullConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* labelItem, CConcept* concept, bool& negationFlag, bool& deterministicFlag) {
if (labelItem) {
CCACHINGHASH* labelValueHash = labelItem->getTagCacheValueHash(false);
cint64 tag = concept->getConceptTag();
if (labelValueHash) {
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (!labelLinker) {
labelLinker = labelValueHash->value(-tag);
if (labelLinker) {
negationFlag = true;
}
} else {
negationFlag = false;
}
if (labelLinker) {
const CCacheValue& cacheValue = labelLinker->getCacheValue();
CConcept* concept = (CConcept*)cacheValue.getIdentification();
bool deterministicFlag = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT || cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDCONCEPT;
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasConceptInAssociatedFullConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* labelItem, CConcept* concept, bool negation) {
if (labelItem) {
CCACHINGHASH* labelValueHash = labelItem->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = concept->getConceptTag();
if (negation) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker) {
return true;
}
}
}
return false;
}
bool CBackendRepresentativeMemoryCacheReader::hasConceptInAssociatedFullConceptSetLabel(CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CBackendRepresentativeMemoryLabelCacheItem* labelItem, CConcept* concept, bool negation, bool deterministic) {
if (labelItem) {
CCACHINGHASH* labelValueHash = labelItem->getTagCacheValueHash(false);
if (labelValueHash) {
cint64 tag = concept->getConceptTag();
if (negation) {
tag = -tag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelLinker = labelValueHash->value(tag);
if (labelLinker && getCacheValue(concept, negation, deterministic) == labelLinker->getCacheValue()) {
return true;
}
}
}
return false;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getLabelCacheEntryViaProvidedCacheValues(cint64 labelType, cint64 signature, cint64 count, function provFunc) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == count) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
CCacheValue cacheValue;
cint64 tag;
bool resetProviding = true;
while (compatible) {
if (!provFunc(resetProviding, tag, cacheValue)) {
break;
}
resetProviding = false;
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(tag);
if (!labelValueLinker || labelValueLinker->getCacheValue() != cacheValue) {
compatible = false;
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getLabelCacheEntryViaRoleLinker(cint64 labelType, cint64 signature, cint64 count, CSortedNegLinker* roleLinker, bool inversed, CRole* assertedRole) {
CSortedNegLinker* roleLinkerIt = roleLinker;
CBackendRepresentativeMemoryLabelCacheItem* labelItem = getLabelCacheEntryViaProvidedCacheValues(labelType, signature, count, [&](bool resetProviding, cint64& tag, CCacheValue& cacheValue)->bool {
if (resetProviding) {
roleLinkerIt = roleLinker;
}
if (!roleLinkerIt) {
return false;
}
CRole* role = roleLinkerIt->getData();
bool roleInversion = roleLinkerIt->isNegated() ^ inversed;
bool assertionLinkBase = role == assertedRole && roleInversion == inversed;
cacheValue = getCacheValue(role, roleInversion, assertionLinkBase, false);
tag = cacheValue.getTag();
roleLinkerIt = roleLinkerIt->getNext();
return true;
});
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getLabelCacheEntryViaRoleAssertionLinker(cint64 labelType, cint64 signature, cint64 count, CBackendRepresentativeMemoryCacheRoleAssertionLinker* roleAssertionLinker) {
CBackendRepresentativeMemoryCacheRoleAssertionLinker* roleAssertionLinkerIt = roleAssertionLinker;
CBackendRepresentativeMemoryLabelCacheItem* labelItem = getLabelCacheEntryViaProvidedCacheValues(labelType, signature, count, [&](bool resetProviding, cint64& tag, CCacheValue& cacheValue)->bool {
if (resetProviding) {
roleAssertionLinkerIt = roleAssertionLinker;
}
if (!roleAssertionLinkerIt) {
return false;
}
CRole* role = roleAssertionLinkerIt->getData();
bool roleInversion = roleAssertionLinkerIt->isNegated();
bool assertionLinkBase = roleAssertionLinkerIt->isABoxAsserted();
bool nominalConnected = roleAssertionLinkerIt->isNominalConnected();
bool nondeterministic = roleAssertionLinkerIt->isNondeterministic();
cacheValue = getCacheValue(role, roleInversion, assertionLinkBase, nominalConnected, nondeterministic);
tag = cacheValue.getTag();
roleAssertionLinkerIt = (CBackendRepresentativeMemoryCacheRoleAssertionLinker*)roleAssertionLinkerIt->getNext();
return true;
});
return labelItem;
}
const CCacheValue CBackendRepresentativeMemoryCacheReader::getCacheValue(CBackendRepresentativeMemoryCacheTemporaryLabelReferenceDataLinker* neigbourRoleInstantiatedSetTmpLabelLinker) {
CBackendRepresentativeMemoryLabelCacheItem* labelCacheItem = neigbourRoleInstantiatedSetTmpLabelLinker->getReferredLabelData();
CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* tmpLabelWriteData = neigbourRoleInstantiatedSetTmpLabelLinker->getReferredTemporaryLabelData();
cint64 tag = 0;
CCacheValue::CACHEVALUEIDENTIFIER cacheValueIdentifier = CCacheValue::CACHE_VALUE_TAG_AND_ENTRY;
cint64 value = (cint64)labelCacheItem;
if (tmpLabelWriteData) {
cacheValueIdentifier = CCacheValue::CACHE_VALUE_TAG_AND_TEMPORARY_ENTRY;
value = (cint64)tmpLabelWriteData;
} else {
tag = labelCacheItem->getCacheEntryID();
}
CCacheValue cacheValue;
cacheValue.initCacheValue(tag, (cint64)value, cacheValueIdentifier);
return cacheValue;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getNeighbourRoleInstantiatedSetCompinationLabelCacheEntry(cint64 signature, cint64 count, CBackendRepresentativeMemoryCacheTemporaryLabelReferenceDataLinker* neigbourRoleInstantiatedSetTmpLabelLinker) {
CBackendRepresentativeMemoryCacheTemporaryLabelReferenceDataLinker* neigbourRoleInstantiatedSetTmpLabelLinkerIt = neigbourRoleInstantiatedSetTmpLabelLinker;
CBackendRepresentativeMemoryLabelCacheItem* labelItem = getLabelCacheEntryViaProvidedCacheValues(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL, signature, count, [&](bool resetProviding, cint64& tag, CCacheValue& cacheValue)->bool {
if (resetProviding) {
neigbourRoleInstantiatedSetTmpLabelLinkerIt = neigbourRoleInstantiatedSetTmpLabelLinker;
}
if (!neigbourRoleInstantiatedSetTmpLabelLinkerIt) {
return false;
}
cacheValue = getCacheValue(neigbourRoleInstantiatedSetTmpLabelLinkerIt);
tag = (cint64)cacheValue.getTag();
neigbourRoleInstantiatedSetTmpLabelLinkerIt = (CBackendRepresentativeMemoryCacheTemporaryLabelReferenceDataLinker*)neigbourRoleInstantiatedSetTmpLabelLinkerIt->getNext();
return true;
});
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getConceptSetLabelCacheEntry(cint64 labelType, cint64 signature, cint64 conCount, CConceptSaturationDescriptor* conDesLinker) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == conCount) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CConceptSaturationDescriptor* conDesIt = conDesLinker; conDesIt && compatible; conDesIt = conDesIt->getNext()) {
cint64 conTag = conDesIt->getConceptTag();
CConcept* concept = conDesIt->getConcept();
bool negation = conDesIt->isNegated();
if (negation) {
conTag = -conTag;
}
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(conTag);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(concept,negation)) {
compatible = false;
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getDeterministicConceptSetLabelCacheEntry(cint64 signature, cint64 conCount, CConceptDescriptor* conDesLinker, cint64 maxDeterministicBranchTag, bool excludePositiveNominalConcepts) {
return getConceptSetLabelCacheEntry(signature, conCount, conDesLinker, true, maxDeterministicBranchTag, excludePositiveNominalConcepts);
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getNondeterministicConceptSetLabelCacheEntry(cint64 signature, cint64 conCount, CConceptDescriptor* conDesLinker, cint64 maxDeterministicBranchTag, bool excludePositiveNominalConcepts) {
return getConceptSetLabelCacheEntry(signature, conCount, conDesLinker, false, maxDeterministicBranchTag, excludePositiveNominalConcepts);
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getConceptSetLabelCacheEntry(cint64 signature, cint64 conCount, CConceptDescriptor* conDesLinker, bool deterministic, cint64 maxDeterministicBranchTag, bool excludePositiveNominalConcepts) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
cint64 labelType = CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_CONCEPT_SET_LABEL;
if (!deterministic) {
labelType = CBackendRepresentativeMemoryLabelCacheItem::NONDETERMINISTIC_CONCEPT_SET_LABEL;
}
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == conCount) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CConceptDescriptor* conDesIt = conDesLinker; conDesIt && compatible; conDesIt = conDesIt->getNext()) {
cint64 conTag = conDesIt->getConceptTag();
CConcept* concept = conDesIt->getConcept();
bool negation = conDesIt->isNegated();
if (negation) {
conTag = -conTag;
}
bool deterministicallyDerived = true;
if (!conDesIt->getDependencyTrackPoint() || conDesIt->getDependencyTrackPoint()->getBranchingTag() > maxDeterministicBranchTag) {
deterministicallyDerived = false;
}
bool considerConcept = deterministicallyDerived == deterministic;
if (excludePositiveNominalConcepts && concept->getOperatorCode() == CCNOMINAL && !negation) {
considerConcept = false;
}
if (considerConcept) {
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(conTag);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(concept, negation)) {
compatible = false;
}
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getFullConceptSetLabelCacheEntry(cint64 labelType, cint64 signature, cint64 conCount, CConceptDescriptor* conDesLinker, function exclusionDetermineFunction, function nondeterministicDetermineFunction) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == conCount) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CConceptDescriptor* conDesIt = conDesLinker; conDesIt && compatible; conDesIt = conDesIt->getNext()) {
cint64 conTag = conDesIt->getConceptTag();
CConcept* concept = conDesIt->getConcept();
bool negation = conDesIt->isNegated();
if (negation) {
conTag = -conTag;
}
bool considerConcept = exclusionDetermineFunction(concept, negation);
if (considerConcept) {
bool deterministicConcept = nondeterministicDetermineFunction(concept, negation, conDesIt->getDependencyTrackPoint());
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(conTag);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(concept, negation, deterministicConcept)) {
compatible = false;
}
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getConceptSetLabelCacheEntry(cint64 labelType, cint64 signature, cint64 conCount, CConceptDescriptor* conDesLinker, function exclusionDetermineFunction) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == conCount) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CConceptDescriptor* conDesIt = conDesLinker; conDesIt && compatible; conDesIt = conDesIt->getNext()) {
cint64 conTag = conDesIt->getConceptTag();
CConcept* concept = conDesIt->getConcept();
bool negation = conDesIt->isNegated();
if (negation) {
conTag = -conTag;
}
bool considerConcept = exclusionDetermineFunction(concept, negation);
if (considerConcept) {
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(conTag);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(concept, negation)) {
compatible = false;
}
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getIndividualSetLabelCacheEntry(cint64 labelType, cint64 signature, cint64 indiId, CDistinctHash* indiDistinctHash, cint64& count, bool onlyDeterministic, cint64 maxDeterministicBranchTag) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == count) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CDistinctHash::const_iterator it = indiDistinctHash->constBegin(), itEnd = indiDistinctHash->constEnd(); it != itEnd; ++it) {
cint64 distinctIndiId = -it.key();
if (distinctIndiId >= 0 && distinctIndiId != indiId) {
CDistinctEdge* distinctEdge = it.value();
bool deterministicallyDerived = true;
if (!distinctEdge->getDependencyTrackPoint() || distinctEdge->getDependencyTrackPoint()->getBranchingTag() > maxDeterministicBranchTag) {
deterministicallyDerived = false;
}
bool considerIndividual = deterministicallyDerived || !onlyDeterministic;
if (considerIndividual) {
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(distinctIndiId);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(distinctIndiId, false)) {
compatible = false;
}
}
}
}
if (compatible && indiId >= 0) {
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(indiId);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(indiId, false)) {
compatible = false;
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getIndividualSetLabelCacheEntry(cint64 labelType, cint64 signature, cint64 indiId, CIndividualMergingHash* indiMerginghash, cint64& count, bool onlyDeterministic, cint64 maxDeterministicBranchTag) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == count) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CIndividualMergingHash::const_iterator it = indiMerginghash->constBegin(), itEnd = indiMerginghash->constEnd(); it != itEnd; ++it) {
if (it.value().isMergedWithIndividual()) {
cint64 mergedIndiId = it.key();
if (mergedIndiId != indiId) {
CIndividualMergingHashData mergedData = it.value();
bool deterministicallyDerived = true;
if (!mergedData.getDependencyTrackPoint() || mergedData.getDependencyTrackPoint()->getBranchingTag() > maxDeterministicBranchTag) {
deterministicallyDerived = false;
}
bool considerIndividual = deterministicallyDerived || !onlyDeterministic;
if (considerIndividual) {
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(mergedIndiId);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(mergedIndiId, false)) {
compatible = false;
}
}
}
}
}
if (compatible && indiId >= 0) {
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(indiId);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(indiId, false)) {
compatible = false;
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
CBackendRepresentativeMemoryLabelCacheItem* CBackendRepresentativeMemoryCacheReader::getIndividualSetLabelCacheEntry(cint64 labelType, cint64 signature, CPROCESSSET* individualSet, cint64& count) {
CBackendRepresentativeMemoryLabelCacheItem* labelItem = nullptr;
CBackendRepresentativeMemoryLabelSignatureResolveCacheItem* sigResEntry = getLabelCacheEntry(labelType, signature);
if (sigResEntry) {
for (CBackendRepresentativeMemoryLabelCacheItem* itemIt = sigResEntry->getLabelItems(); itemIt && !labelItem; itemIt = itemIt->getNext()) {
if (itemIt->getCacheValueCount() == count) {
bool compatible = true;
CCACHINGHASH* cacheValueHash = itemIt->getTagCacheValueHash(false);
for (CPROCESSSET::const_iterator it = individualSet->constBegin(), itEnd = individualSet->constEnd(); it != itEnd; ++it) {
cint64 indiId = *it;
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = cacheValueHash->value(indiId);
if (!labelValueLinker || labelValueLinker->getCacheValue() != getCacheValue(indiId, false)) {
compatible = false;
}
}
if (compatible) {
labelItem = itemIt;
}
}
}
}
return labelItem;
}
}; // end namespace Cache
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude