/*
* 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 "CSaturationNodeBackendAssociationCacheHandler.h"
namespace Konclude {
namespace Reasoner {
namespace Kernel {
namespace Algorithm {
CSaturationNodeBackendAssociationCacheHandler::CSaturationNodeBackendAssociationCacheHandler(CBackendRepresentativeMemoryCacheReader* backAssCacheReader, CBackendRepresentativeMemoryCacheWriter* backAssCacheWriter, COccurrenceStatisticsCacheWriter* occStatsCacheWriter) : CBackendAssociationCacheHandler(backAssCacheReader, backAssCacheWriter) {
mOccStatsCacheWriter = occStatsCacheWriter;
mConfDirectCardinalityInsufficient = false;
mConfOccurrenceStatisticsCounting = true;
}
void CSaturationNodeBackendAssociationCacheHandler::readCalculationConfig(CCalculationConfigurationExtension* config) {
if (config) {
mConfOccurrenceStatisticsCounting = config->isOccurrenceStatisticsCollectionActivated();
} else {
mConfOccurrenceStatisticsCounting = true;
}
}
bool CSaturationNodeBackendAssociationCacheHandler::determineCardinalityAssociationBackendItem(CIndividualSaturationProcessNode* satNode, CPROCESSHASH* roleUsedCardHash, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
if (mConfDirectCardinalityInsufficient) {
tmpAssWriteDataLinker->setCompletelyHandled(false);
tmpAssWriteDataLinker->setCompletelySaturated(false);
tmpAssWriteDataLinker->setCompletelyPropagated(false);
return false;
} else {
function* superRoleTagUsedCardCountHash)> initFunc = [&](CPROCESSHASH* superRoleTagUsedCardCountHash)->void {
CReapplyConceptSaturationLabelSet* conSet = satNode->getReapplyConceptSaturationLabelSet(false);
if (conSet) {
for (CConceptSaturationDescriptor* conSatDesIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesIt; conSatDesIt = conSatDesIt->getNext()) {
CConcept* concept = conSatDesIt->getConcept();
bool negation = conSatDesIt->isNegated();
cint64 conOpCode = concept->getOperatorCode();
if (!negation && conOpCode == CCATMOST || negation && conOpCode == CCATLEAST) {
CRole* role = concept->getRole();
cint64 cardinality = concept->getParameter();
if (negation && conOpCode == CCATLEAST) {
cardinality = cardinality - 1;
}
CRoleCardinalityCountData& cardCountData = (*superRoleTagUsedCardCountHash)[role->getRoleTag()];
if (!cardCountData.mHasRestrictingCardinality) {
cardCountData.mHasRestrictingCardinality = true;
cardCountData.mRestrictingCardinality = cardinality;
} else {
cardCountData.mRestrictingCardinality = qMin(cardCountData.mRestrictingCardinality, cardinality);
}
}
}
}
};
return CBackendAssociationCacheHandler::determineCardinalityAssociationBackendItem(initFunc, roleUsedCardHash, true, tmpAssWriteDataLinker, calcAlgContext);
}
}
bool CSaturationNodeBackendAssociationCacheHandler::collectConceptOccurrenceStatistics(CIndividualSaturationProcessNode* indiNode, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptSaturationLabelSet* conSet = indiNode->getReapplyConceptSaturationLabelSet(false);
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
for (CConceptSaturationDescriptor* conSatDesLinkerIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesLinkerIt; conSatDesLinkerIt = conSatDesLinkerIt->getNext()) {
CConcept* concept = conSatDesLinkerIt->getConcept();
mOccStatsCacheWriter->incConceptInstanceOccurrencceStatistics(ontology, concept->getConceptTag(), 1, 0, 1, 0);
}
return true;
}
bool CSaturationNodeBackendAssociationCacheHandler::determineFullConceptSetLabelAssociationBackendItem(CIndividualSaturationProcessNode* satNode, cint64 labelType, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptSaturationLabelSet* conSet = satNode->getReapplyConceptSaturationLabelSet(false);
if (!conSet) {
return false;
}
CIndividualSaturationProcessNode* copiedNode = satNode->getCopyIndividualNode();
if (copiedNode && copiedNode->getReapplyConceptSaturationLabelSet(false) && copiedNode->getReapplyConceptSaturationLabelSet(false)->getConceptSaturationDescriptionLinker() == conSet->getConceptSaturationDescriptionLinker()) {
return determineFullConceptSetLabelAssociationBackendItem(copiedNode, labelType,tmpAssWriteDataLinker,calcAlgContext);
}
QPair* hashedRefPair = nullptr;
if (satNode->getNominalIndividual() == nullptr) {
QPair& refPair = (*mIndiNodeRefDetConceptSetLabelHash)[satNode];
if (refPair.first) {
tmpAssWriteDataLinker->setReferredLabelData(labelType, refPair.first);
++mStatReusedHashedIndiLabels;
return true;
} else if (refPair.second) {
tmpAssWriteDataLinker->setReferredTemporaryLabelData(labelType, refPair.second);
++mStatReusedHashedIndiLabels;
return true;
}
hashedRefPair = &refPair;
}
cint64 conCount = conSet->getConceptCount();
cint64 conSetSigValue = CBackendRepresentativeMemoryCacheUtilities::getConceptDescriptorSignature(conSet->getConceptSaturationDescriptionLinker(), conCount, nullptr);
CBackendRepresentativeMemoryLabelCacheItem* cachedLabelItem = mAssBackCacheReader->getConceptSetLabelCacheEntry(labelType, conSetSigValue,conSet->getConceptCount(),conSet->getConceptSaturationDescriptionLinker());
if (cachedLabelItem) {
++mStatReusedCachedLabels;
if (hashedRefPair) {
hashedRefPair->first = cachedLabelItem;
}
tmpAssWriteDataLinker->setReferredLabelData(labelType, cachedLabelItem);
return true;
}
CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker*& prevTempRefLabels = (*mSignatureTmpRefDetConceptSetLabelHash)[conSetSigValue];
if (prevTempRefLabels) {
for (CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* prevTempRefLabelIt = prevTempRefLabels; prevTempRefLabelIt; prevTempRefLabelIt = prevTempRefLabelIt->getNext()) {
if (prevTempRefLabelIt->getCacheValueCount() == conSet->getConceptCount()) {
bool compatibleConcepts = true;
for (CBackendRepresentativeMemoryLabelValueLinker* labelValueLinkerIt = prevTempRefLabelIt->getCacheValueLinker(); labelValueLinkerIt && compatibleConcepts; labelValueLinkerIt = labelValueLinkerIt->getNext()) {
CCacheValue& cacheValue = labelValueLinkerIt->getCacheValue();
CConcept* concept = (CConcept*)cacheValue.getIdentification();
bool negation = cacheValue.getCacheValueIdentifier() == CCacheValue::CACHEVALTAGANDNEGATEDCONCEPT;
if (!conSet->hasConcept(concept,negation)) {
compatibleConcepts = false;
}
}
if (compatibleConcepts) {
++mStatReusedHashedSignatureLabels;
++mStatReusedTempLabels;
if (hashedRefPair) {
hashedRefPair->second = prevTempRefLabelIt;
}
tmpAssWriteDataLinker->setReferredTemporaryLabelData(labelType, prevTempRefLabelIt);
return true;
}
}
}
}
CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* newTempRefLabel = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker >::allocateAndConstruct(mMemAllocMan);
newTempRefLabel->initLabelWriteData(conSetSigValue, labelType);
CIndividualSaturationProcessNodeStatusFlags* indFlags = satNode->getIndirectStatusFlags();
CIndividualSaturationProcessNodeStatusFlags* dirFlags = satNode->getDirectStatusFlags();
bool insufficient = indFlags->hasInsufficientFlag() || !indFlags->hasCompletedFlag() || !dirFlags->hasCompletedFlag();
if (!insufficient) {
newTempRefLabel->setCompletelySaturated(true);
newTempRefLabel->setCompletelyHandled(true);
newTempRefLabel->setCompletelyPropagated(true);
}
for (CConceptSaturationDescriptor* conSatDesIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesIt; conSatDesIt = conSatDesIt->getNext()) {
CConcept* concept = conSatDesIt->getConcept();
bool negation = conSatDesIt->isNegated();
CBackendRepresentativeMemoryLabelValueLinker* labelValueLinker = CObjectAllocator< CBackendRepresentativeMemoryLabelValueLinker >::allocateAndConstruct(mMemAllocMan);
labelValueLinker->initLabelValueLinker(getCacheValue(concept,negation));
newTempRefLabel->appendCacheValueLinker(labelValueLinker);
}
mNewTmpLabelList->append(newTempRefLabel);
++mStatCreatedTempLabels;
if (hashedRefPair) {
hashedRefPair->second = newTempRefLabel;
}
tmpAssWriteDataLinker->setReferredTemporaryLabelData(labelType, newTempRefLabel);
prevTempRefLabels = newTempRefLabel->append(prevTempRefLabels);
return true;
}
bool CSaturationNodeBackendAssociationCacheHandler::collectSelfRestrictionRoles(CIndividualSaturationProcessNode* satNode, CPROCESSSET*& roleInstantiatedSet, CSortedNegLinker*& roleInstantiatedLinker, CCalculationAlgorithmContext* calcAlgContext) {
bool hasSelf = false;
CRole* topRole = calcAlgContext->getProcessingDataBox()->getOntology()->getRBox()->getTopObjectRole();
CReapplyConceptSaturationLabelSet* conSet = satNode->getReapplyConceptSaturationLabelSet(false);
for (CConceptSaturationDescriptor* conSatDesIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesIt; conSatDesIt = conSatDesIt->getNext()) {
CConcept* concept = conSatDesIt->getConcept();
bool conNegation = conSatDesIt->isNegated();
cint64 conCode = concept->getOperatorCode();
CRole* role = concept->getRole();
bool existentialSuccessorCand = false;
if (role != topRole) {
if (!conNegation && conCode == CCSELF) {
if (!roleInstantiatedSet->contains(TRoleInversionPair(role, false))) {
CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
roleInstantiatedLinker = roleLinker->init(role, false, roleInstantiatedLinker);
roleInstantiatedSet->insert(TRoleInversionPair(role, false));
}
if (!roleInstantiatedSet->contains(TRoleInversionPair(role, true))) {
CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
roleInstantiatedLinker = roleLinker->init(role, true, roleInstantiatedLinker);
roleInstantiatedSet->insert(TRoleInversionPair(role, true));
}
hasSelf = true;
}
}
}
return hasSelf;
}
bool CSaturationNodeBackendAssociationCacheHandler::determineSaturationNodeIndividualCombinedNeighbourRoleInstantiatedSetLabelAssociationBackendItem(CIndividualSaturationProcessNode* satNode, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnDataLinker = mNominalIndiIdRoleConnectionDataHash->value(satNode->getNominalIndividual()->getIndividualID());
CIndividualSaturationProcessNodeExtensionData* extensionData = satNode->getIndividualExtensionData(false);
if (!extensionData && !nominalConnDataLinker) {
return false;
}
CPROCESSSET* combinedNeigbourRoleInstantiatedSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CSortedNegLinker* combinedNeigbourRoleInstantiatedLinker = nullptr;
bool selfRestrictions = collectSelfRestrictionRoles(satNode, combinedNeigbourRoleInstantiatedSet, combinedNeigbourRoleInstantiatedLinker, calcAlgContext);
CLinkedNeighbourRoleAssertionSaturationHash* linkedNeighbourRoleAssHash = extensionData->getLinkedNeighbourRoleAssertionHash(false);
if (!selfRestrictions && !linkedNeighbourRoleAssHash && !nominalConnDataLinker) {
return false;
}
CRole* topRole = calcAlgContext->getProcessingDataBox()->getOntology()->getRBox()->getTopObjectRole();
CPROCESSHASH* neighbourRoleAssertionDataHash = nullptr;
if (linkedNeighbourRoleAssHash) {
neighbourRoleAssertionDataHash = linkedNeighbourRoleAssHash->getNeighbourRoleAssertionDataHash();
}
if (neighbourRoleAssertionDataHash) {
for (CPROCESSHASH::const_iterator it = neighbourRoleAssertionDataHash->constBegin(), itEnd = neighbourRoleAssertionDataHash->constEnd(); it != itEnd; ++it) {
cint64 neighbourIndiId = it.key();
CLinkedNeighbourRoleAssertionSaturationData* data = it.value();
for (CLinkedNeighbourRoleAssertionLinker* linkedRoleAssertedLinkerIt = data->getLinkedRoleAssertedLinker(); linkedRoleAssertedLinkerIt; linkedRoleAssertedLinkerIt = linkedRoleAssertedLinkerIt->getNext()) {
CRole* role = linkedRoleAssertedLinkerIt->getAssertedRole();
bool inversed = linkedRoleAssertedLinkerIt->isAssertedRoleInversed();
if (role != topRole && !combinedNeigbourRoleInstantiatedSet->contains(TRoleInversionPair(role, inversed))) {
CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
combinedNeigbourRoleInstantiatedLinker = roleLinker->init(role, inversed, combinedNeigbourRoleInstantiatedLinker);
combinedNeigbourRoleInstantiatedSet->insert(TRoleInversionPair(role, inversed));
}
}
}
}
for (CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnData = nominalConnDataLinker; nominalConnData; nominalConnData = nominalConnData->getNext()) {
CRole* role = nominalConnData->getConnectionRole();
bool inversed = nominalConnData->isInversedConnection();
if (role != topRole && !combinedNeigbourRoleInstantiatedSet->contains(TRoleInversionPair(role, inversed))) {
CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
combinedNeigbourRoleInstantiatedLinker = roleLinker->init(role, inversed, combinedNeigbourRoleInstantiatedLinker);
combinedNeigbourRoleInstantiatedSet->insert(TRoleInversionPair(role, inversed));
}
}
if (combinedNeigbourRoleInstantiatedLinker) {
CBackendRepresentativeMemoryCacheTemporaryLabelReference labelRef = getRoleInstantiatedSetLabelAssociationBackendItem(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL, combinedNeigbourRoleInstantiatedLinker, combinedNeigbourRoleInstantiatedSet, true, mRoleInversionSetTmpRefRoleInstantiatedSetLabelHashTypeArray[CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL], calcAlgContext);
tmpAssWriteDataLinker->setReferredLabel(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL, labelRef);
if (mConfOccurrenceStatisticsCounting) {
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
visitRolesOfAssociatedCompinationRoleSetLabel(labelRef, [&](CRole* role, bool inversed)->bool {
if (!inversed) {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(ontology, role->getRoleTag(), 1, 0, 1, 0, 0, 0);
}
return true;
}, calcAlgContext);
}
return true;
}
else {
return false;
}
}
CIndividualSaturationProcessNode* CSaturationNodeBackendAssociationCacheHandler::getSuccessorSaturationNode(CConceptSaturationDescriptor* conDes, CIndividualSaturationProcessNode* satNode, CCalculationAlgorithmContext* calcAlgContext) {
CConcept* concept = conDes->getConcept();
bool conNegation = conDes->isNegated();
CRole* role = concept->getRole();
CConceptData* conceptData = concept->getConceptData();
if (conceptData) {
CConceptProcessData* conProcData = (CConceptProcessData*)conceptData;
CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
if (conRefLinking) {
CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking;
CSaturationConceptReferenceLinking* extSatCalcRefLinkData = confSatRefLinkingData->getExistentialSuccessorConceptSaturationReferenceLinkingData();
if (extSatCalcRefLinkData) {
CIndividualSaturationProcessNode* existIndiNode = (CIndividualSaturationProcessNode*)extSatCalcRefLinkData->getIndividualProcessNodeForConcept();
if (existIndiNode) {
return existIndiNode;
}
}
}
}
CSortedNegLinker* conceptOpLinkerIt = concept->getOperandList();
while (conceptOpLinkerIt) {
CConcept* opConcept = conceptOpLinkerIt->getData();
bool opConNegation = conceptOpLinkerIt->isNegated() ^ conNegation;
CConceptData* opConceptData = opConcept->getConceptData();
if (opConceptData) {
CConceptProcessData* conProcData = (CConceptProcessData*)opConceptData;
CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
if (conRefLinking) {
CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking;
CSaturationConceptReferenceLinking* satCalcRefLinkData = confSatRefLinkingData->getConceptSaturationReferenceLinkingData(opConNegation);
if (satCalcRefLinkData) {
CIndividualSaturationProcessNode* existIndiNode = (CIndividualSaturationProcessNode*)satCalcRefLinkData->getIndividualProcessNodeForConcept();
if (existIndiNode) {
return existIndiNode;
}
}
}
}
conceptOpLinkerIt = conceptOpLinkerIt->getNext();
}
CConcept* baseTopConcept = nullptr;
if (!role->isDataRole()) {
baseTopConcept = calcAlgContext->getUsedProcessingDataBox()->getOntologyTopConcept();
} else {
baseTopConcept = calcAlgContext->getUsedProcessingDataBox()->getOntologyTopDataRangeConcept();
}
CConcept* opConcept = baseTopConcept;
bool opConNegation = false;
CConceptData* opConceptData = opConcept->getConceptData();
if (opConceptData) {
CConceptProcessData* conProcData = (CConceptProcessData*)opConceptData;
CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
if (conRefLinking) {
CConceptSaturationReferenceLinkingData* confSatRefLinkingData = (CConceptSaturationReferenceLinkingData*)conRefLinking;
CSaturationConceptReferenceLinking* satCalcRefLinkData = confSatRefLinkingData->getConceptSaturationReferenceLinkingData(opConNegation);
if (satCalcRefLinkData) {
CIndividualSaturationProcessNode* existIndiNode = (CIndividualSaturationProcessNode*)satCalcRefLinkData->getIndividualProcessNodeForConcept();
if (existIndiNode) {
return existIndiNode;
}
}
}
}
return nullptr;
}
bool CSaturationNodeBackendAssociationCacheHandler::collectSaturationNodeSuccessorRelatedRoles(cint64 satIndiId, CIndividualSaturationProcessNode* satNode, CPROCESSSET** roleSet, CSortedNegLinker** roleLinker,
CRole* role, CIndividualSaturationProcessNode* succSatNode, CSaturationSuccessorData* succData,
CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >* nominalIndiIdRoleConnectionDataHash, CPROCESSSET** existentialIndirectlyConnectedNominalIndividualSet, CPROCESSHASH* roleUsedCardHash, CCalculationAlgorithmContext* calcAlgContext) {
bool collected = false;
if (roleSet && !(*roleSet)->contains(TRoleInversionPair(role, false))) {
(*roleSet)->insert(TRoleInversionPair(role, false));
collected = true;
CSortedNegLinker* newRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
*roleLinker = newRoleLinker->init(role, false, *roleLinker);
if (roleUsedCardHash) {
cint64 cardCount = 1;
if (succData) {
cardCount = succData->mSuccCount;
}
(*roleUsedCardHash)[role] += cardCount;
}
}
if (mConfOccurrenceStatisticsCounting && succSatNode && !succSatNode->isSeparated()) {
succSatNode->setOccurrenceStatisticsCollectingRequired(true);
}
if (succSatNode && succSatNode->getIndirectStatusFlags()->hasNominalConnectionFlag()) {
CSuccessorConnectedNominalSet* succConnNomSet = succSatNode->getSuccessorConnectedNominalSet(false);
if (succConnNomSet && existentialIndirectlyConnectedNominalIndividualSet) {
for (CSuccessorConnectedNominalSet::const_iterator it = succConnNomSet->constBegin(), itEnd = succConnNomSet->constEnd(); it != itEnd; ++it) {
cint64 nomIndiId = *it;
if (!*existentialIndirectlyConnectedNominalIndividualSet) {
*existentialIndirectlyConnectedNominalIndividualSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
}
(*existentialIndirectlyConnectedNominalIndividualSet)->insert(nomIndiId);
}
}
}
if (nominalIndiIdRoleConnectionDataHash && (succSatNode && succSatNode->getIntegratedNominalIndividual() || succData && succData->mVALUENominalConnection)) {
cint64 nominalId = -1;
if (succSatNode && succSatNode->getIntegratedNominalIndividual()) {
nominalId = succSatNode->getIntegratedNominalIndividual()->getIndividualID();
} else if (succData && succData->mVALUENominalConnection) {
nominalId = succData->mVALUENominalID;
}
collected = true;
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData*& prevNominalConnectionData = (*nominalIndiIdRoleConnectionDataHash)[nominalId];
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* newNominalConnectionData = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
newNominalConnectionData->initNominalRoleConnectionData(role, true, CIndividualReference(satIndiId));
newNominalConnectionData->setNext(prevNominalConnectionData);
prevNominalConnectionData = newNominalConnectionData;
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData*& prevSaturationNodeConnectionData = (*nominalIndiIdRoleConnectionDataHash)[satIndiId];
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* newSaturationNodeConnectionData = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
newSaturationNodeConnectionData->initNominalRoleConnectionData(role, false, CIndividualReference(nominalId));
newSaturationNodeConnectionData->setNext(prevSaturationNodeConnectionData);
prevSaturationNodeConnectionData = newSaturationNodeConnectionData;
}
return collected;
}
bool CSaturationNodeBackendAssociationCacheHandler::collectSaturationNodeSuccessorRelatedRoles(cint64 satIndiId, CIndividualSaturationProcessNode* satNode, CPROCESSSET** roleSet, CSortedNegLinker** roleLinker,
bool collectExistentialConnectionRoles, bool collectNominalConnectionRoles, bool collectDataConnectionRoles, bool analyseConcepts, bool analyseSuccessorLinks,
CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >* nominalIndiIdRoleConnectionDataHash, CPROCESSSET** existentialIndirectlyConnectedNominalIndividualSet, CPROCESSHASH* roleUsedCardHash,
CPROCESSHASH* successorRelatedNodesAlternativeCheckingHash, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptSaturationLabelSet* conSet = satNode->getReapplyConceptSaturationLabelSet(false);
if (!conSet) {
return false;
}
CLinkedRoleSaturationSuccessorHash* linkedSuccHash = satNode->getLinkedRoleSuccessorHash(false);
CIndividualSaturationProcessNode* copiedNode = satNode->getCopyIndividualNode();
if (copiedNode && copiedNode->getReapplyConceptSaturationLabelSet(false) && copiedNode->getReapplyConceptSaturationLabelSet(false)->getConceptSaturationDescriptionLinker() == conSet->getConceptSaturationDescriptionLinker() && (!linkedSuccHash || copiedNode->getLinkedRoleSuccessorHash(false))) {
return collectSaturationNodeSuccessorRelatedRoles(satIndiId, copiedNode, roleSet, roleLinker, collectExistentialConnectionRoles, collectNominalConnectionRoles, collectDataConnectionRoles, analyseConcepts, analyseSuccessorLinks, nominalIndiIdRoleConnectionDataHash, existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, successorRelatedNodesAlternativeCheckingHash, calcAlgContext);
}
bool collected = false;
CRole* topRole = calcAlgContext->getProcessingDataBox()->getOntology()->getRBox()->getTopObjectRole();
if (analyseSuccessorLinks && linkedSuccHash) {
CPROCESSHASH* linkSuccDatahash = linkedSuccHash->getLinkedRoleSuccessorHash();
for (CPROCESSHASH::const_iterator it = linkSuccDatahash->constBegin(), itEnd = linkSuccDatahash->constEnd(); it != itEnd; ++it) {
CRole* role = it.key();
CLinkedRoleSaturationSuccessorData* linkSuccData = it.value();
if (role != topRole && linkSuccData->mSuccCount > 0) {
CPROCESSMAP* succNodeMap = linkSuccData->getSuccessorNodeDataMap(false);
for (CPROCESSMAP::const_iterator succIt = succNodeMap->constBegin(), succItEnd = succNodeMap->constEnd(); succIt != succItEnd; ++succIt) {
CSaturationSuccessorData* succData = succIt.value();
if (succData->mActiveCount > 0) {
CIndividualSaturationProcessNode* succSatNode = succData->mSuccIndiNode;
bool collectSuccessorNode = true;
if (succSatNode && succSatNode->isABoxIndividualRepresentationNode()) {
collectSuccessorNode = false;
}
if (succSatNode && succSatNode->getIntegratedNominalIndividual() || succData->mVALUENominalConnection) {
if (!collectNominalConnectionRoles) {
collectSuccessorNode = false;
}
} else {
if (role->isDataRole()) {
if (!collectDataConnectionRoles) {
collectSuccessorNode = false;
}
} else {
if (!collectExistentialConnectionRoles) {
collectSuccessorNode = false;
}
}
}
if (collectSuccessorNode) {
collected |= collectSaturationNodeSuccessorRelatedRoles(satIndiId, satNode, roleSet, roleLinker, role, succSatNode, succData, nominalIndiIdRoleConnectionDataHash, existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, calcAlgContext);
}
}
}
}
}
} else if (analyseConcepts) {
for (CConceptSaturationDescriptor* conSatDesIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesIt; conSatDesIt = conSatDesIt->getNext()) {
CConcept* concept = conSatDesIt->getConcept();
bool conNegation = conSatDesIt->isNegated();
cint64 conCode = concept->getOperatorCode();
CRole* role = concept->getRole();
bool existentialSuccessorCand = false;
if (role != topRole) {
if (!conNegation && conCode == CCVALUE && collectNominalConnectionRoles) {
CSaturationSuccessorData succData;
succData.mVALUENominalConnection = true;
succData.mVALUENominalID = concept->getNominalIndividual()->getIndividualID();
collected |= collectSaturationNodeSuccessorRelatedRoles(satIndiId, satNode, roleSet, roleLinker, role, nullptr, &succData, nominalIndiIdRoleConnectionDataHash, existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, calcAlgContext);
}
if (!conNegation && conCode == CCATLEAST || conNegation && conCode == CCATMOST) {
CIndividualSaturationProcessNode* succSatNode = getSuccessorSaturationNode(conSatDesIt, satNode, calcAlgContext);
CSaturationSuccessorData succData;
succData.mSuccCount = concept->getParameter();
if (conNegation) {
succData.mSuccCount--;
}
bool collectSuccessorNode = true;
if (successorRelatedNodesAlternativeCheckingHash) {
CSuccessorRelatedNodesAlternativeCheckingData alternativeCheckingData = successorRelatedNodesAlternativeCheckingHash->value(TRoleInversionPair(role, false));
for (CXLinker* alternativeNodeLinkerIt = alternativeCheckingData.mCheckingNodeLinker; alternativeNodeLinkerIt && collectSuccessorNode; alternativeNodeLinkerIt = alternativeNodeLinkerIt->getNext()) {
CIndividualSaturationProcessNode* alternativeCheckingNode = alternativeNodeLinkerIt->getData();
if (alternativeCheckingNode && succData.mSuccCount == 1) {
bool containsExistentiallyRestrictedConcept = true;
if (concept->getOperandList()) {
for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt && containsExistentiallyRestrictedConcept; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opCon = opConLinkerIt->getData();
bool opConNeg = opConLinkerIt->isNegated();
if (!alternativeCheckingNode->getReapplyConceptSaturationLabelSet(false) || !alternativeCheckingNode->getReapplyConceptSaturationLabelSet(false)->containsConcept(opCon, opConNeg)) {
containsExistentiallyRestrictedConcept = false;
}
}
}
if (containsExistentiallyRestrictedConcept) {
collectSuccessorNode = false;
}
}
}
}
if (collectSuccessorNode) {
collected |= collectSaturationNodeSuccessorRelatedRoles(satIndiId, satNode, roleSet, roleLinker, role, succSatNode, &succData, nominalIndiIdRoleConnectionDataHash, existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, calcAlgContext);
}
}
if (!conNegation && (conCode == CCSOME || conCode == CCAQSOME) || conNegation && (conCode == CCALL)) {
existentialSuccessorCand = true;
}
if (role && existentialSuccessorCand) {
CIndividualSaturationProcessNode* succSatNode = getSuccessorSaturationNode(conSatDesIt, satNode, calcAlgContext);
if (succSatNode) {
bool collectSuccessorNode = true;
if (succSatNode->getIntegratedNominalIndividual()) {
if (!collectNominalConnectionRoles) {
collectSuccessorNode = false;
}
} else {
if (role->isDataRole()) {
if (!collectDataConnectionRoles) {
collectSuccessorNode = false;
}
} else {
if (!collectExistentialConnectionRoles) {
collectSuccessorNode = false;
}
}
}
if (collectSuccessorNode && successorRelatedNodesAlternativeCheckingHash) {
CSuccessorRelatedNodesAlternativeCheckingData alternativeCheckingData = successorRelatedNodesAlternativeCheckingHash->value(TRoleInversionPair(role, false));
for (CXLinker* alternativeNodeLinkerIt = alternativeCheckingData.mCheckingNodeLinker; alternativeNodeLinkerIt && collectSuccessorNode; alternativeNodeLinkerIt = alternativeNodeLinkerIt->getNext()) {
CIndividualSaturationProcessNode* alternativeCheckingNode = alternativeNodeLinkerIt->getData();
if (alternativeCheckingNode) {
bool containsExistentiallyRestrictedConcept = true;
if (concept->getOperandList()) {
for (CSortedNegLinker* opConLinkerIt = concept->getOperandList(); opConLinkerIt && containsExistentiallyRestrictedConcept; opConLinkerIt = opConLinkerIt->getNext()) {
CConcept* opCon = opConLinkerIt->getData();
bool opConNeg = opConLinkerIt->isNegated() ^ conNegation;
if (!alternativeCheckingNode->getReapplyConceptSaturationLabelSet(false) || !alternativeCheckingNode->getReapplyConceptSaturationLabelSet(false)->containsConcept(opCon, opConNeg)) {
containsExistentiallyRestrictedConcept = false;
}
}
}
if (containsExistentiallyRestrictedConcept) {
collectSuccessorNode = false;
}
}
}
}
if (collectSuccessorNode) {
collected |= collectSaturationNodeSuccessorRelatedRoles(satIndiId, satNode, roleSet, roleLinker, role, succSatNode, nullptr, nominalIndiIdRoleConnectionDataHash, existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, calcAlgContext);
}
}
}
}
}
}
return collected;
}
bool CSaturationNodeBackendAssociationCacheHandler::determineCombinedExistentialRoleInstantiatedSetLabelAssociationBackendItem(CIndividualSaturationProcessNode* satNode, CPROCESSSET** existentialIndirectlyConnectedNominalIndividualSet, CPROCESSHASH* roleUsedCardHash, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
CPROCESSHASH* successorRelatedNodesAlternativeCheckingHash = nullptr;
CIndividualSaturationProcessNodeExtensionData* extensionData = satNode->getIndividualExtensionData(false);
// don't use it at the moment since it causes errors
// TODO: fix
CRole* topRole = calcAlgContext->getProcessingDataBox()->getOntology()->getRBox()->getTopObjectRole();
if (extensionData) {
CLinkedNeighbourRoleAssertionSaturationHash* linkedNeighbourRoleAssHash = extensionData->getLinkedNeighbourRoleAssertionHash(false);
CPROCESSHASH* neighbourRoleAssertionDataHash = nullptr;
if (linkedNeighbourRoleAssHash) {
neighbourRoleAssertionDataHash = linkedNeighbourRoleAssHash->getNeighbourRoleAssertionDataHash();
}
if (neighbourRoleAssertionDataHash) {
successorRelatedNodesAlternativeCheckingHash = CObjectParameterizingAllocator< CPROCESSHASH, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CRole* lastRole = nullptr;
bool lastRoleInversion = false;
cint64 lastRoleUsedCount = 0;
for (CPROCESSHASH::const_iterator it = neighbourRoleAssertionDataHash->constBegin(), itEnd = neighbourRoleAssertionDataHash->constEnd(); it != itEnd; ++it) {
cint64 neighbourIndiId = it.key();
CLinkedNeighbourRoleAssertionSaturationData* data = it.value();
for (CLinkedNeighbourRoleAssertionSaturationNodeLinker* linkedRoleAssertedLinkerIt = data->getLinkedRoleAssertedLinker(); linkedRoleAssertedLinkerIt; linkedRoleAssertedLinkerIt = (CLinkedNeighbourRoleAssertionSaturationNodeLinker*)linkedRoleAssertedLinkerIt->getNext()) {
CRole* role = linkedRoleAssertedLinkerIt->getAssertedRole();
bool inversed = linkedRoleAssertedLinkerIt->isAssertedRoleInversed();
if ((role == lastRole && lastRoleInversion == inversed && lastRoleUsedCount < 3) || role != lastRole || lastRoleInversion != inversed) {
if (role == lastRole && lastRoleInversion == inversed) {
++lastRoleUsedCount;
} else {
lastRole = role;
lastRoleInversion = inversed;
lastRoleUsedCount = 0;
}
CIndividualSaturationProcessNode* connectedSatNode = linkedRoleAssertedLinkerIt->getConnectedSaturationNode();
for (CSortedNegLinker* superRoleLinkerIt = role->getIndirectSuperRoleList(); superRoleLinkerIt; superRoleLinkerIt = superRoleLinkerIt->getNext()) {
CRole* superRole = superRoleLinkerIt->getData();
bool superRoleInversion = inversed ^ superRoleLinkerIt->isNegated();
if (superRole != topRole && !superRoleInversion) {
CSuccessorRelatedNodesAlternativeCheckingData& checkingData = (*successorRelatedNodesAlternativeCheckingHash)[TRoleInversionPair(superRole, superRoleInversion)];
if (!checkingData.mRole) {
checkingData.mRole = superRole;
checkingData.mInversed = superRoleInversion;
}
if (checkingData.mCheckingNodeCount < 3) {
CXLinker* checkingNodeLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
checkingNodeLinker->initLinker(connectedSatNode);
checkingData.mCheckingNodeLinker = checkingNodeLinker->append(checkingData.mCheckingNodeLinker);
}
}
}
}
}
}
}
}
CPROCESSSET* combinedExistentialRoleInstantiatedSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CSortedNegLinker* combinedExistentialRoleInstantiatedLinker = nullptr;
collectSaturationNodeSuccessorRelatedRoles(satNode->getIndividualID(), satNode, &combinedExistentialRoleInstantiatedSet, &combinedExistentialRoleInstantiatedLinker, true, false, false, true, true, nullptr, existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, successorRelatedNodesAlternativeCheckingHash, calcAlgContext);
if (combinedExistentialRoleInstantiatedLinker) {
CBackendRepresentativeMemoryCacheTemporaryLabelReference labelRef = getRoleInstantiatedSetLabelAssociationBackendItem(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_EXISTENTIAL_INSTANTIATED_ROLE_SET_LABEL, combinedExistentialRoleInstantiatedLinker, combinedExistentialRoleInstantiatedSet, true, mRoleInversionSetTmpRefRoleInstantiatedSetLabelHashTypeArray[CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_EXISTENTIAL_INSTANTIATED_ROLE_SET_LABEL], calcAlgContext);
tmpAssWriteDataLinker->setReferredLabel(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_EXISTENTIAL_INSTANTIATED_ROLE_SET_LABEL, labelRef);
if (mConfOccurrenceStatisticsCounting) {
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
visitRolesOfAssociatedCompinationRoleSetLabel(labelRef, [&](CRole* role, bool inversed)->bool {
if (!inversed) {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(ontology, role->getRoleTag(), 1, 0, 1, 0, 0, 0);
} else if (role->getInverseRole()) {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(ontology, role->getInverseRole()->getRoleTag(), 1, 0, 0, 1, 0, 0);
}
return true;
}, calcAlgContext);
}
return true;
} else {
return false;
}
}
bool CSaturationNodeBackendAssociationCacheHandler::determineCombinedDataRoleInstantiatedSetLabelAssociationBackendItem(CIndividualSaturationProcessNode* satNode, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
CPROCESSSET* combinedDataRoleInstantiatedSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CSortedNegLinker* combinedDataRoleInstantiatedLinker = nullptr;
// TODO: only do this, if there are data value concepts, i.e., set flag if data value concepts are used
collectSaturationNodeSuccessorRelatedRoles(satNode->getIndividualID(), satNode, &combinedDataRoleInstantiatedSet, &combinedDataRoleInstantiatedLinker, false, false, true, true, true, nullptr, nullptr, nullptr, nullptr, calcAlgContext);
CLinkedDataValueAssertionSaturationData* dataValueAssertionsData = satNode->getLinkedDataValueAssertionData(false);
if (dataValueAssertionsData) {
for (CXLinker* dataRoleIt = dataValueAssertionsData->getDataValueRoleAssertionLinker(); dataRoleIt; dataRoleIt = dataRoleIt->getNext()) {
CRole* dataRole = dataRoleIt->getData();
if (!combinedDataRoleInstantiatedSet->contains(TRoleInversionPair(dataRole, false))) {
combinedDataRoleInstantiatedSet->insert(TRoleInversionPair(dataRole, false));
CSortedNegLinker* newRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
combinedDataRoleInstantiatedLinker = newRoleLinker->init(dataRole, false, combinedDataRoleInstantiatedLinker);
}
}
}
if (combinedDataRoleInstantiatedLinker) {
CBackendRepresentativeMemoryCacheTemporaryLabelReference labelRef = getRoleInstantiatedSetLabelAssociationBackendItem(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_DATA_INSTANTIATED_ROLE_SET_LABEL, combinedDataRoleInstantiatedLinker, combinedDataRoleInstantiatedSet, true, mRoleInversionSetTmpRefRoleInstantiatedSetLabelHashTypeArray[CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_DATA_INSTANTIATED_ROLE_SET_LABEL], calcAlgContext);
tmpAssWriteDataLinker->setReferredLabel(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_DATA_INSTANTIATED_ROLE_SET_LABEL, labelRef);
return true;
} else {
return false;
}
}
bool CSaturationNodeBackendAssociationCacheHandler::determineSaturationNodeIndividualNeighbourRoleInstantiatedSetCompinationLabelAssociationBackendItem(CIndividualSaturationProcessNode* satNode, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnection = mNominalIndiIdRoleConnectionDataHash->value(satNode->getNominalIndividual()->getIndividualID());
CIndividualSaturationProcessNodeExtensionData* extensionData = satNode->getIndividualExtensionData(false);
if (!extensionData && !nominalConnection) {
return false;
}
CPROCESSSET* selfRoleInstantiatedSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CSortedNegLinker* selfRoleInstantiatedLinker = nullptr;
bool selfRestrictions = collectSelfRestrictionRoles(satNode, selfRoleInstantiatedSet, selfRoleInstantiatedLinker, calcAlgContext);
CLinkedNeighbourRoleAssertionSaturationHash* linkedNeighbourRoleAssHash = extensionData->getLinkedNeighbourRoleAssertionHash(false);
if (!selfRestrictions && !linkedNeighbourRoleAssHash && !nominalConnection) {
return false;
}
CPROCESSSET* neigbourRoleInstantiatedSetCompination = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >* mNominalNeighbourIndiIdRoleConnectionDataHash = nullptr;
if (nominalConnection) {
mNominalIndiIdRoleConnectionDataHash->remove(satNode->getNominalIndividual()->getIndividualID());
mNominalNeighbourIndiIdRoleConnectionDataHash = CObjectParameterizingAllocator< CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
for (CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnectionIt = nominalConnection; nominalConnectionIt; nominalConnectionIt = nominalConnectionIt->getNext()) {
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData*& neigbbourNominalConnectionDataLinker = (*mNominalNeighbourIndiIdRoleConnectionDataHash)[nominalConnectionIt->getConnectedIndividual().getIndividualID()];
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* newNeigbbourNominalConnectionDataLinker = CObjectAllocator::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
newNeigbbourNominalConnectionDataLinker->initNominalRoleConnectionData(nominalConnectionIt->getConnectionRole(), nominalConnectionIt->isInversedConnection(), nominalConnectionIt->getConnectedIndividual());
neigbbourNominalConnectionDataLinker = newNeigbbourNominalConnectionDataLinker->append(neigbbourNominalConnectionDataLinker);
}
}
CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker* roleSetNeighbourUpdateLinker = nullptr;
if (selfRoleInstantiatedLinker) {
CBackendRepresentativeMemoryCacheRoleAssertionLinker* superRoleAssertionLinker = nullptr;
CPROCESSHASH* superRoleInversionLinkerHash = CObjectParameterizingAllocator< CPROCESSHASH, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CRole* topRole = calcAlgContext->getProcessingDataBox()->getOntology()->getRBox()->getTopObjectRole();
for (CSortedNegLinker* selfRoleInstantiatedLinkerIt = selfRoleInstantiatedLinker; selfRoleInstantiatedLinkerIt; selfRoleInstantiatedLinkerIt = selfRoleInstantiatedLinkerIt->getNext()) {
CRole* role = selfRoleInstantiatedLinkerIt->getData();
bool inversed = selfRoleInstantiatedLinkerIt->isNegated();
for (CSortedNegLinker* superRoleLinkerIt = role->getIndirectSuperRoleList(); superRoleLinkerIt; superRoleLinkerIt = superRoleLinkerIt->getNext()) {
CRole* superRole = superRoleLinkerIt->getData();
bool superRoleNegation = superRoleLinkerIt->isNegated() ^ inversed;
if (superRole != topRole && superRoleInversionLinkerHash->value(TRoleInversionPair(superRole, superRoleNegation)) == nullptr) {
CBackendRepresentativeMemoryCacheRoleAssertionLinker* newRoleLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheRoleAssertionLinker >::allocateAndConstruct(calcAlgContext->getMemoryAllocationManager());
newRoleLinker->initRoleAssertionLinker(superRole, superRoleNegation, false, true, false);
superRoleInversionLinkerHash->insert(TRoleInversionPair(superRole, superRoleNegation), newRoleLinker);
superRoleAssertionLinker = (CBackendRepresentativeMemoryCacheRoleAssertionLinker*)newRoleLinker->append(superRoleAssertionLinker);
}
}
}
CBackendRepresentativeMemoryCacheTemporaryLabelReference neighbourRoleSetLabelRef = getNeighbourRoleInstantiatedSetLabelAssociationBackendItem(nullptr, superRoleAssertionLinker, nullptr, calcAlgContext);
neigbourRoleInstantiatedSetCompination->insert(neighbourRoleSetLabelRef);
CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker* newRoleSetNeighbourUpdateLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker >::allocateAndConstruct(mMemAllocMan);
newRoleSetNeighbourUpdateLinker->initRoleSetNeighbourUpdateDataLinker(neighbourRoleSetLabelRef, satNode->getNominalIndividual()->getIndividualID());
roleSetNeighbourUpdateLinker = newRoleSetNeighbourUpdateLinker->append(roleSetNeighbourUpdateLinker);
}
CPROCESSHASH* neighbourRoleAssertionDataHash = nullptr;
if (linkedNeighbourRoleAssHash) {
neighbourRoleAssertionDataHash = linkedNeighbourRoleAssHash->getNeighbourRoleAssertionDataHash();
}
if (neighbourRoleAssertionDataHash) {
for (CPROCESSHASH::const_iterator it = neighbourRoleAssertionDataHash->constBegin(), itEnd = neighbourRoleAssertionDataHash->constEnd(); it != itEnd; ++it) {
cint64 neighbourIndiId = it.key();
CLinkedNeighbourRoleAssertionSaturationData* data = it.value();
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalNeighbourConnection = nullptr;
if (mNominalNeighbourIndiIdRoleConnectionDataHash) {
nominalNeighbourConnection = mNominalNeighbourIndiIdRoleConnectionDataHash->value(neighbourIndiId);
mNominalNeighbourIndiIdRoleConnectionDataHash->remove(neighbourIndiId);
}
CBackendRepresentativeMemoryCacheTemporaryLabelReference neighbourRoleSetLabelRef;
CLinkedNeighbourRoleAssertionLinker* linkedRoleAssertedLinker = data->getLinkedRoleAssertedLinker();
if (linkedRoleAssertedLinker && !linkedRoleAssertedLinker->hasNext() && !nominalNeighbourConnection) {
CRole* role = linkedRoleAssertedLinker->getAssertedRole();
bool inversed = linkedRoleAssertedLinker->isAssertedRoleInversed();
neighbourRoleSetLabelRef = getNeighbourRoleInstantiatedSetLabelAssociationBackendItem(role, inversed, calcAlgContext);
neigbourRoleInstantiatedSetCompination->insert(neighbourRoleSetLabelRef);
} else {
neighbourRoleSetLabelRef = getNeighbourRoleInstantiatedSetLabelAssociationBackendItem(linkedRoleAssertedLinker, nullptr, nominalNeighbourConnection, calcAlgContext);
neigbourRoleInstantiatedSetCompination->insert(neighbourRoleSetLabelRef);
}
CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker* newRoleSetNeighbourUpdateLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker >::allocateAndConstruct(mMemAllocMan);
newRoleSetNeighbourUpdateLinker->initRoleSetNeighbourUpdateDataLinker(neighbourRoleSetLabelRef, neighbourIndiId);
roleSetNeighbourUpdateLinker = newRoleSetNeighbourUpdateLinker->append(roleSetNeighbourUpdateLinker);
}
}
if (mNominalNeighbourIndiIdRoleConnectionDataHash && !mNominalNeighbourIndiIdRoleConnectionDataHash->isEmpty()) {
for (CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >::const_iterator it = mNominalNeighbourIndiIdRoleConnectionDataHash->constBegin(), itEnd = mNominalNeighbourIndiIdRoleConnectionDataHash->constEnd(); it != itEnd; ++it) {
cint64 neighbourIndiId = it.key();
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalNeighbourConnection = it.value();
CBackendRepresentativeMemoryCacheTemporaryLabelReference neighbourRoleSetLabelRef = getNeighbourRoleInstantiatedSetLabelAssociationBackendItem(nullptr, nullptr, nominalNeighbourConnection, calcAlgContext);
neigbourRoleInstantiatedSetCompination->insert(neighbourRoleSetLabelRef);
CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker* newRoleSetNeighbourUpdateLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker >::allocateAndConstruct(mMemAllocMan);
newRoleSetNeighbourUpdateLinker->initRoleSetNeighbourUpdateDataLinker(neighbourRoleSetLabelRef, neighbourIndiId);
roleSetNeighbourUpdateLinker = newRoleSetNeighbourUpdateLinker->append(roleSetNeighbourUpdateLinker);
}
}
tmpAssWriteDataLinker->setRoleSetNeighbourUpdateDataLinker(roleSetNeighbourUpdateLinker);
return determineNeighbourRoleInstantiatedSetCompinationLabelAssociationBackendItem(neigbourRoleInstantiatedSetCompination, tmpAssWriteDataLinker, calcAlgContext);
}
bool CSaturationNodeBackendAssociationCacheHandler::determineNominalIndividualIdNeighbourRoleInstantiatedSetCompinationLabelAssociationBackendItem(cint64 nominalId, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnection, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker* roleSetNeighbourUpdateLinker = nullptr;
CBackendRepresentativeMemoryCacheIndividualAssociationData* indiAssData = mAssBackCacheReader->getIndividualAssociationData(nominalId);
CBackendRepresentativeMemoryLabelCacheItem* existingNeighbourRoleInstantiatedSetCompinationLabel = nullptr;
if (indiAssData) {
existingNeighbourRoleInstantiatedSetCompinationLabel = indiAssData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::NEIGHBOUR_INSTANTIATED_ROLE_SET_COMBINATION_LABEL);
}
CBackendRepresentativeMemoryCacheIndividualNeighbourRoleSetHash* existingNeighbourRoleSetHash = nullptr;
if (indiAssData) {
existingNeighbourRoleSetHash = indiAssData->getNeighbourRoleSetHash();
}
bool updated = false;
CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >* mNominalNeighbourIndiIdRoleConnectionDataHash = nullptr;
if (nominalConnection) {
mNominalNeighbourIndiIdRoleConnectionDataHash = CObjectParameterizingAllocator< CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
for (CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnectionIt = nominalConnection; nominalConnectionIt; nominalConnectionIt = nominalConnectionIt->getNext()) {
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData*& neigbbourNominalConnectionDataLinker = (*mNominalNeighbourIndiIdRoleConnectionDataHash)[nominalConnectionIt->getConnectedIndividual().getIndividualID()];
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* newNeigbbourNominalConnectionDataLinker = CObjectAllocator::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
newNeigbbourNominalConnectionDataLinker->initNominalRoleConnectionData(nominalConnectionIt->getConnectionRole(), nominalConnectionIt->isInversedConnection(), nominalConnectionIt->getConnectedIndividual());
neigbbourNominalConnectionDataLinker = newNeigbbourNominalConnectionDataLinker->append(neigbbourNominalConnectionDataLinker);
}
}
CPROCESSSET* neigbourRoleInstantiatedSetCompination = nullptr;
for (CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >::const_iterator it = mNominalNeighbourIndiIdRoleConnectionDataHash->constBegin(), itEnd = mNominalNeighbourIndiIdRoleConnectionDataHash->constEnd(); it != itEnd; ++it) {
cint64 neighbourIndiId = it.key();
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnectionData = it.value();
CBackendRepresentativeMemoryLabelCacheItem* prevNeighbourRoleSetLabel = nullptr;
if (existingNeighbourRoleSetHash) {
prevNeighbourRoleSetLabel = existingNeighbourRoleSetHash->getNeighbourRoleSetLabel(neighbourIndiId);
}
bool updateRequired = false;
if (!prevNeighbourRoleSetLabel) {
updateRequired = true;
} else {
for (CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnectionIt = nominalConnectionData; !updateRequired && nominalConnectionIt; nominalConnectionIt = nominalConnectionIt->getNext()) {
if (!mAssBackCacheReader->hasRoleInAssociatedNeigbourRoleSetLabel(indiAssData, prevNeighbourRoleSetLabel, nominalConnectionIt->getConnectionRole(), nominalConnectionIt->isInversedConnection(), false, true, false)) {
updateRequired = true;
}
}
}
if (updateRequired) {
CBackendRepresentativeMemoryCacheRoleAssertionLinker* linkedRoleAssertedLinker = nullptr;
if (prevNeighbourRoleSetLabel) {
mAssBackCacheReader->visitRolesOfAssociatedNeigbourRoleSetLabel(indiAssData, prevNeighbourRoleSetLabel, [&](CRole* role, bool inversed, bool aboxAsserted, bool nominalConnection, bool nondeterministic)->bool {
CBackendRepresentativeMemoryCacheRoleAssertionLinker* newLinkedRoleAssertedLinker = CObjectAllocator::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
newLinkedRoleAssertedLinker->initRoleAssertionLinker(role, inversed, aboxAsserted, nominalConnection, nondeterministic);
linkedRoleAssertedLinker = (CBackendRepresentativeMemoryCacheRoleAssertionLinker*)newLinkedRoleAssertedLinker->append(linkedRoleAssertedLinker);
return true;
});
}
CBackendRepresentativeMemoryCacheTemporaryLabelReference neighbourRoleSetLabelRef = getNeighbourRoleInstantiatedSetLabelAssociationBackendItem(nullptr, linkedRoleAssertedLinker, nominalConnectionData, calcAlgContext);
CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker* newRoleSetNeighbourUpdateLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryIndividualRoleSetNeighbourUpdateDataLinker >::allocateAndConstruct(mMemAllocMan);
newRoleSetNeighbourUpdateLinker->initRoleSetNeighbourUpdateDataLinker(neighbourRoleSetLabelRef, neighbourIndiId);
roleSetNeighbourUpdateLinker = newRoleSetNeighbourUpdateLinker->append(roleSetNeighbourUpdateLinker);
if (neighbourRoleSetLabelRef.getReferredTemporaryLabelData() || !checkNeighbourRoleInstantiatedSetCompinationLabelContainsNeighbourRoleInstantiatedSet(existingNeighbourRoleInstantiatedSetCompinationLabel, neighbourRoleSetLabelRef, calcAlgContext)) {
if (!neigbourRoleInstantiatedSetCompination) {
neigbourRoleInstantiatedSetCompination = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
}
neigbourRoleInstantiatedSetCompination->insert(neighbourRoleSetLabelRef);
}
updated = true;
}
}
tmpAssWriteDataLinker->setRoleSetNeighbourUpdateDataLinker(roleSetNeighbourUpdateLinker);
if (neigbourRoleInstantiatedSetCompination) {
if (indiAssData) {
mAssBackCacheReader->visitLabelsOfAssociatedNeigbourRoleSetCombinationLabel(indiAssData, existingNeighbourRoleInstantiatedSetCompinationLabel, [&](CBackendRepresentativeMemoryLabelCacheItem* label)->bool {
neigbourRoleInstantiatedSetCompination->insert(CBackendRepresentativeMemoryCacheTemporaryLabelReference(label));
return true;
});
}
updated |= determineNeighbourRoleInstantiatedSetCompinationLabelAssociationBackendItem(neigbourRoleInstantiatedSetCompination, tmpAssWriteDataLinker, calcAlgContext);
}
return updated;
}
bool CSaturationNodeBackendAssociationCacheHandler::determineNominalIndividualIdCombinedNeighbourRoleInstantiatedSetLabelAssociationBackendItem(cint64 nominalId, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnDataLinker, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
bool updateRequired = false;
bool updated = false;
CBackendRepresentativeMemoryCacheIndividualAssociationData* indiAssData = mAssBackCacheReader->getIndividualAssociationData(nominalId);
CBackendRepresentativeMemoryLabelCacheItem* existingDeterministicCombinedNeighbourRoleInstantiatedSetLabel = nullptr;
if (indiAssData) {
existingDeterministicCombinedNeighbourRoleInstantiatedSetLabel = indiAssData->getLabelCacheEntry(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL);
}
for (CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnData = nominalConnDataLinker; !updateRequired && nominalConnData; nominalConnData = nominalConnData->getNext()) {
if (!mAssBackCacheReader->hasRoleInAssociatedNeigbourRoleSetLabel(indiAssData, existingDeterministicCombinedNeighbourRoleInstantiatedSetLabel, nominalConnData->getConnectionRole(), nominalConnData->isInversedConnection(), false, true, false)) {
updateRequired = true;
}
}
if (updateRequired) {
CPROCESSSET* combinedNeigbourRoleInstantiatedSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CSortedNegLinker* combinedNeigbourRoleInstantiatedLinker = nullptr;
if (existingDeterministicCombinedNeighbourRoleInstantiatedSetLabel) {
mAssBackCacheReader->visitRolesOfAssociatedNeigbourRoleSetLabel(indiAssData, existingDeterministicCombinedNeighbourRoleInstantiatedSetLabel, [&](CRole* role, bool inversed, bool aboxAsserted, bool nominalConnection, bool nondeterministic)->bool {
if (!combinedNeigbourRoleInstantiatedSet->contains(TRoleInversionPair(role, inversed))) {
CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
combinedNeigbourRoleInstantiatedLinker = roleLinker->init(role, inversed, combinedNeigbourRoleInstantiatedLinker);
combinedNeigbourRoleInstantiatedSet->insert(TRoleInversionPair(role, inversed));
}
return true;
});
}
for (CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnData = nominalConnDataLinker; nominalConnData; nominalConnData = nominalConnData->getNext()) {
CRole* role = nominalConnData->getConnectionRole();
bool inversed = nominalConnData->isInversedConnection();
if (!combinedNeigbourRoleInstantiatedSet->contains(TRoleInversionPair(role, inversed))) {
CSortedNegLinker* roleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
combinedNeigbourRoleInstantiatedLinker = roleLinker->init(role, inversed, combinedNeigbourRoleInstantiatedLinker);
combinedNeigbourRoleInstantiatedSet->insert(TRoleInversionPair(role, inversed));
}
}
CBackendRepresentativeMemoryCacheTemporaryLabelReference labelRef = getRoleInstantiatedSetLabelAssociationBackendItem(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL, combinedNeigbourRoleInstantiatedLinker, combinedNeigbourRoleInstantiatedSet, true, mRoleInversionSetTmpRefRoleInstantiatedSetLabelHashTypeArray[CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL], calcAlgContext);
tmpAssWriteDataLinker->setReferredLabel(CBackendRepresentativeMemoryLabelCacheItem::DETERMINISTIC_COMBINED_NEIGHBOUR_INSTANTIATED_ROLE_SET_LABEL, labelRef);
if (mConfOccurrenceStatisticsCounting) {
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
visitRolesOfAssociatedCompinationRoleSetLabel(labelRef, [&](CRole* role, bool inversed)->bool {
if (!inversed) {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(ontology, role->getRoleTag(), 1, 0, 1, 0, 0, 0);
}
return true;
}, calcAlgContext);
}
updated = true;
}
return updated;
}
bool CSaturationNodeBackendAssociationCacheHandler::collectNominalRelatedRoles(cint64 satIndiId, cint64 nominalId, CIndividualSaturationProcessNode* satNode, CPROCESSSET** roleSet, CSortedNegLinker** roleLinker,
CRole* role, CCalculationAlgorithmContext* calcAlgContext) {
bool collected = false;
// collect inversed since we are interested in the roles from the perspective of the nominal
if (roleSet && !(*roleSet)->contains(TRoleInversionPair(role, true))) {
(*roleSet)->insert(TRoleInversionPair(role, true));
collected = true;
CSortedNegLinker* newRoleLinker = CObjectAllocator< CSortedNegLinker >::allocateAndConstruct(calcAlgContext->getUsedTemporaryMemoryAllocationManager());
*roleLinker = newRoleLinker->init(role, true, *roleLinker);
}
return collected;
}
bool CSaturationNodeBackendAssociationCacheHandler::collectNominalRelatedRoles(cint64 satIndiId, cint64 nominalId, CIndividualSaturationProcessNode* satNode, CPROCESSSET** roleSet, CSortedNegLinker** roleLinker, CCalculationAlgorithmContext* calcAlgContext) {
CReapplyConceptSaturationLabelSet* conSet = satNode->getReapplyConceptSaturationLabelSet(false);
if (!conSet) {
return false;
}
CLinkedRoleSaturationSuccessorHash* linkedSuccHash = satNode->getLinkedRoleSuccessorHash(false);
CIndividualSaturationProcessNode* copiedNode = satNode->getCopyIndividualNode();
if (copiedNode && copiedNode->getReapplyConceptSaturationLabelSet(false) && copiedNode->getReapplyConceptSaturationLabelSet(false)->getConceptSaturationDescriptionLinker() == conSet->getConceptSaturationDescriptionLinker() && (!linkedSuccHash || copiedNode->getLinkedRoleSuccessorHash(false))) {
return collectNominalRelatedRoles(satIndiId, nominalId, copiedNode, roleSet, roleLinker, calcAlgContext);
}
bool collected = false;
CRole* topRole = calcAlgContext->getProcessingDataBox()->getOntology()->getRBox()->getTopObjectRole();
if (linkedSuccHash) {
CPROCESSHASH* linkSuccDatahash = linkedSuccHash->getLinkedRoleSuccessorHash();
for (CPROCESSHASH::const_iterator it = linkSuccDatahash->constBegin(), itEnd = linkSuccDatahash->constEnd(); it != itEnd; ++it) {
CRole* role = it.key();
CLinkedRoleSaturationSuccessorData* linkSuccData = it.value();
if (role != topRole && linkSuccData->mSuccCount > 0) {
CPROCESSMAP* succNodeMap = linkSuccData->getSuccessorNodeDataMap(false);
for (CPROCESSMAP::const_iterator succIt = succNodeMap->constBegin(), succItEnd = succNodeMap->constEnd(); succIt != succItEnd; ++succIt) {
CSaturationSuccessorData* succData = succIt.value();
if (succData->mActiveCount > 0) {
CIndividualSaturationProcessNode* succSatNode = succData->mSuccIndiNode;
bool collectSuccessorNode = false;
if (succData->mVALUENominalConnection && succData->mVALUENominalID == nominalId) {
collectSuccessorNode = true;
}
if (succSatNode && succSatNode->getIntegratedNominalIndividual() && succSatNode->getIntegratedNominalIndividual()->getIndividualID() == nominalId) {
collectSuccessorNode = true;
}
if (collectSuccessorNode) {
collected |= collectNominalRelatedRoles(satIndiId, nominalId, satNode, roleSet, roleLinker, role, calcAlgContext);
}
}
}
}
}
} else {
for (CConceptSaturationDescriptor* conSatDesIt = conSet->getConceptSaturationDescriptionLinker(); conSatDesIt; conSatDesIt = conSatDesIt->getNext()) {
CConcept* concept = conSatDesIt->getConcept();
bool conNegation = conSatDesIt->isNegated();
cint64 conCode = concept->getOperatorCode();
CRole* role = concept->getRole();
bool collectSuccessorNode = false;
bool existentialSuccessorCand = false;
if (!conNegation && (conCode == CCSOME || conCode == CCAQSOME) || conNegation && (conCode == CCALL)) {
existentialSuccessorCand = true;
}
if (!conNegation && conCode == CCATLEAST || conNegation && conCode == CCATMOST) {
existentialSuccessorCand = true;
}
if (!conNegation && conCode == CCVALUE) {
collectSuccessorNode = true;
}
if (role && existentialSuccessorCand) {
CIndividualSaturationProcessNode* succSatNode = getSuccessorSaturationNode(conSatDesIt, satNode, calcAlgContext);
if (succSatNode && succSatNode->getIntegratedNominalIndividual() && succSatNode->getIntegratedNominalIndividual()->getIndividualID() == nominalId) {
collectSuccessorNode = true;
}
}
if (role != topRole && collectSuccessorNode) {
collected |= collectNominalRelatedRoles(satIndiId, nominalId, satNode, roleSet, roleLinker, role, calcAlgContext);
}
}
}
return collected;
}
bool CSaturationNodeBackendAssociationCacheHandler::collectNominalRelatedRolesFromPredecessors(cint64 satIndiId, cint64 nominalId, CIndividualSaturationProcessNode* satIndiNode, CPROCESSSET** roleSet, CSortedNegLinker** roleLinker, CCalculationAlgorithmContext* calcAlgContext) {
bool collected = false;
CPROCESSSET< CIndividualSaturationProcessNode* >* handledSatNodeSet = CObjectParameterizingAllocator< CPROCESSSET< CIndividualSaturationProcessNode* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CRoleBackwardSaturationPropagationHash* backwardPropHash = satIndiNode->getRoleBackwardPropagationHash(false);
if (backwardPropHash) {
CPROCESSHASH* backPropHash = backwardPropHash->getRoleBackwardPropagationDataHash();
for (CPROCESSHASH::const_iterator it = backPropHash->constBegin(), itEnd = backPropHash->constEnd(); it != itEnd; ++it) {
const CRoleBackwardSaturationPropagationHashData& backwardPropData = it.value();
for (CBackwardSaturationPropagationLink* linkIt = backwardPropData.mLinkLinker; linkIt; linkIt = linkIt->getNext()) {
CIndividualSaturationProcessNode* sourceIndividual = linkIt->getSourceIndividual();
if (!handledSatNodeSet->contains(sourceIndividual)) {
handledSatNodeSet->insert(sourceIndividual);
collected |= collectNominalRelatedRoles(satIndiId, nominalId, sourceIndividual, roleSet, roleLinker, calcAlgContext);
}
}
}
}
for (CXLinker* nonInvConnIndiLinkerIt = satIndiNode->getNonInverseConnectedIndividualNodeLinker(); nonInvConnIndiLinkerIt; nonInvConnIndiLinkerIt = nonInvConnIndiLinkerIt->getNext()) {
CIndividualSaturationProcessNode* sourceIndividual = nonInvConnIndiLinkerIt->getData();
if (!handledSatNodeSet->contains(sourceIndividual)) {
handledSatNodeSet->insert(sourceIndividual);
collected |= collectNominalRelatedRoles(satIndiId, nominalId, sourceIndividual, roleSet, roleLinker, calcAlgContext);
}
}
return collected;
}
bool CSaturationNodeBackendAssociationCacheHandler::determineNominalIndividualIdPossiblyExistentialRoleInstantiatedSetLabelAssociationBackendItem(cint64 nominalId, CSaturationNominalDependentNodeData* nomDepNodeData, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker, CCalculationAlgorithmContext* calcAlgContext) {
bool updated = false;
CPROCESSSET* combinedNeigbourRoleInstantiatedSet = CObjectParameterizingAllocator< CPROCESSSET, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CSortedNegLinker* combinedNeigbourRoleInstantiatedLinker = nullptr;
for (CSaturationNominalDependentNodeData* nominalDepData = nomDepNodeData; nominalDepData; nominalDepData = nominalDepData->getNext()) {
CIndividualSaturationProcessNode* depNode = nominalDepData->getDependentIndividualSaturationNode();
if (nominalDepData->getNominalConnectionType() == CSaturationNominalDependentNodeData::VALUECONNECTION) {
collectNominalRelatedRoles(depNode->getIndividualID(), nominalId, depNode, &combinedNeigbourRoleInstantiatedSet, &combinedNeigbourRoleInstantiatedLinker, calcAlgContext);
} else if (nominalDepData->getNominalConnectionType() == CSaturationNominalDependentNodeData::NOMINALCONNECTION) {
collectNominalRelatedRolesFromPredecessors(depNode->getIndividualID(), nominalId, depNode, &combinedNeigbourRoleInstantiatedSet, &combinedNeigbourRoleInstantiatedLinker, calcAlgContext);
}
}
if (combinedNeigbourRoleInstantiatedLinker) {
CBackendRepresentativeMemoryCacheTemporaryLabelReference labelRef = getRoleInstantiatedSetLabelAssociationBackendItem(CBackendRepresentativeMemoryLabelCacheItem::NONDETERMINISTIC_COMBINED_EXISTENTIAL_INSTANTIATED_ROLE_SET_LABEL, combinedNeigbourRoleInstantiatedLinker, combinedNeigbourRoleInstantiatedSet, true, mRoleInversionSetTmpRefRoleInstantiatedSetLabelHashTypeArray[CBackendRepresentativeMemoryLabelCacheItem::NONDETERMINISTIC_COMBINED_EXISTENTIAL_INSTANTIATED_ROLE_SET_LABEL], calcAlgContext);
tmpAssWriteDataLinker->setReferredLabel(CBackendRepresentativeMemoryLabelCacheItem::NONDETERMINISTIC_COMBINED_EXISTENTIAL_INSTANTIATED_ROLE_SET_LABEL, labelRef);
updated = true;
if (mConfOccurrenceStatisticsCounting) {
CConcreteOntology* ontology = calcAlgContext->getProcessingDataBox()->getOntology();
visitRolesOfAssociatedCompinationRoleSetLabel(labelRef, [&](CRole* role, bool inversed)->bool {
if (!inversed) {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(ontology, role->getRoleTag(), 0, 1, 1, 0, 0, 0);
} else if (role->getInverseRole()) {
mOccStatsCacheWriter->incRoleInstanceOccurrencceStatistics(ontology, role->getInverseRole()->getRoleTag(), 0, 1, 0, 1, 0, 0);
}
return true;
}, calcAlgContext);
}
}
return updated;
}
bool CSaturationNodeBackendAssociationCacheHandler::tryAssociateNodesWithBackendCache(CIndividualSaturationProcessNodeLinker* indiSaturationAnalysingNodeLinker, CSatisfiableTaskRepresentativeBackendUpdatingAdapter* repbackUpdAdapter, CCalculationAlgorithmContext* calcAlgContext) {
calcAlgContext->mUsedTempMemMan = nullptr;
mIndiNodeRefDetConceptSetLabelHash = CObjectParameterizingAllocator< CPROCESSHASH< CIndividualSaturationProcessNode*,QPair >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
mSignatureTmpRefDetConceptSetLabelHash = CObjectParameterizingAllocator< CPROCESSHASH, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
mTmpConceptLabelTmpCardDataHash = CObjectParameterizingAllocator< CPROCESSHASH< CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker*, CBackendRepresentativeMemoryCacheTemporaryCardinalityWriteDataLinker* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(),calcAlgContext->getUsedTaskProcessorContext());
mSignatureTmpRefNeigbourRoleInstantiatedSetCombinationLabelHash = CObjectParameterizingAllocator< CPROCESSHASH, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
mRoleInversionTmpRefNeighbourInstantiatedRoleSetLabelHash = CObjectParameterizingAllocator< CPROCESSHASH< TRoleInversionPair, CBackendRepresentativeMemoryCacheTemporaryLabelReference* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
mSuperRoleSignatureCacheValueTmpRefNeighbourInstantiatedRoleSetLabelPairHash = CObjectParameterizingAllocator< CPROCESSHASH< cint64, CCacheValueTmpLabelReferenceData* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
for (cint64 i = 0; i < CBackendRepresentativeMemoryLabelCacheItem::LABEL_CACHE_ITEM_TYPE_COUNT; ++i) {
mRoleInversionSetTmpRefRoleInstantiatedSetLabelHashTypeArray[i] = CObjectParameterizingAllocator< CPROCESSHASH< CProcessSetHasher, CBackendRepresentativeMemoryCacheTemporaryLabelReference* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
}
mNominalIndiIdRoleConnectionDataHash = CObjectParameterizingAllocator< CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
mNewTmpLabelList = CObjectParameterizingAllocator< CPROCESSLIST< CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
mNewTmpCardList = CObjectParameterizingAllocator< CPROCESSLIST< CBackendRepresentativeMemoryCacheTemporaryCardinalityWriteDataLinker* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
mSignatureTmpIndiConnIndiSetRefLabelHash = CObjectParameterizingAllocator< CPROCESSHASH, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* >* nominalIndirectConnectionUpdateDataLinkerHash = CObjectParameterizingAllocator< CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* >, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
prepareCacheMessages(calcAlgContext);
CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinker = nullptr;
CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* lastTmpAssWriteDataLinker = nullptr;
CBackendRepresentativeMemoryCacheTemporaryAssociationUseDataLinker* tmpAssUseDataLinker = nullptr;
CIndividualRepresentativeBackendCacheLoadedAssociationHash* indiLoadedAssocHash = calcAlgContext->getUsedProcessingDataBox()->getBackendCacheLoadedAssociationHash(true);
indiLoadedAssocHash->unshareAll();
CSaturationNominalDependentNodeHash* nominalDependentNodeHash = calcAlgContext->getUsedProcessingDataBox()->getSaturationNominalDependentNodeHash(false);
for (CIndividualSaturationProcessNodeLinker* indiSaturationAnalysingNodeLinkerIt = indiSaturationAnalysingNodeLinker; indiSaturationAnalysingNodeLinkerIt; indiSaturationAnalysingNodeLinkerIt = indiSaturationAnalysingNodeLinkerIt->getNext()) {
CIndividualSaturationProcessNode* satNode = indiSaturationAnalysingNodeLinkerIt->getProcessingIndividual();
CIndividual* nominalIndividual = satNode->getNominalIndividual();
if (nominalIndividual) {
CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* newAssWriteDataLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker >::allocateAndConstruct(mMemAllocMan);
if (!nominalIndividual->isTemporaryIndividual()) {
newAssWriteDataLinker->initAccociationWriteData(nominalIndividual, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker::ADDITION, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker::ADDITION);
} else {
newAssWriteDataLinker->initAccociationWriteData(nominalIndividual->getIndividualID(), CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker::ADDITION, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker::ADDITION);
}
if (mConfOccurrenceStatisticsCounting) {
collectConceptOccurrenceStatistics(satNode, calcAlgContext);
}
determineFullConceptSetLabelAssociationBackendItem(satNode, CBackendRepresentativeMemoryLabelCacheItem::FULL_CONCEPT_SET_LABEL, newAssWriteDataLinker,calcAlgContext);
CPROCESSSET* existentialIndirectlyConnectedNominalIndividualSet = nullptr;
CPROCESSHASH* roleUsedCardHash = nullptr;
if (satNode->getReapplyConceptSaturationLabelSet(false)->getConceptFlags()->containsATMOSTCardinalityFlags()) {
roleUsedCardHash = CObjectParameterizingAllocator< CPROCESSHASH, CContext* >::allocateAndConstructAndParameterize(calcAlgContext->getUsedTemporaryMemoryAllocationManager(), calcAlgContext->getUsedTaskProcessorContext());
}
determineCombinedExistentialRoleInstantiatedSetLabelAssociationBackendItem(satNode, &existentialIndirectlyConnectedNominalIndividualSet, roleUsedCardHash, newAssWriteDataLinker, calcAlgContext);
determineCombinedDataRoleInstantiatedSetLabelAssociationBackendItem(satNode, newAssWriteDataLinker, calcAlgContext);
if (roleUsedCardHash) {
determineCardinalityAssociationBackendItem(satNode, roleUsedCardHash, newAssWriteDataLinker, calcAlgContext);
}
if (existentialIndirectlyConnectedNominalIndividualSet) {
determineIndirectlyConnectedNominalIndividualSetLabelAssociationBackendItem(existentialIndirectlyConnectedNominalIndividualSet, newAssWriteDataLinker, calcAlgContext);
for (CPROCESSSET::const_iterator it = existentialIndirectlyConnectedNominalIndividualSet->constBegin(), itEnd = existentialIndirectlyConnectedNominalIndividualSet->constEnd(); it != itEnd; ++it) {
cint64 nomIndiId = *it;
//TODO: only add linker if the individual was not already connected to the nominal (based on the previous indirectly connected nominal individual set label)
CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker*& nomIndiConnDataLinker = (*nominalIndirectConnectionUpdateDataLinkerHash)[nomIndiId];
if (!nomIndiConnDataLinker) {
nomIndiConnDataLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker >::allocateAndConstruct(mMemAllocMan);
nomIndiConnDataLinker->initNominalIndirectConnectionData(nomIndiId);
if (indiLoadedAssocHash && indiLoadedAssocHash->contains(satNode->getIndividualID())) {
CIndividualRepresentativeBackendCacheLoadedAssociationData& assoLoadingData = (*indiLoadedAssocHash)[satNode->getIndividualID()];
if (assoLoadingData.getLoadedIndividualAssociationData()) {
nomIndiConnDataLinker->setLastChangeIntegrationId(assoLoadingData.getLoadedIndividualAssociationData()->getLastIntegratedIndirectlyConnectedIndividualsChangeId());
}
}
}
CXLinker* indiIdLinker = CObjectAllocator< CXLinker >::allocateAndConstruct(mMemAllocMan);
indiIdLinker->initLinker(nominalIndividual->getIndividualID());
nomIndiConnDataLinker->addIndirectlyConnectedIndividualIdLinker(indiIdLinker);
}
}
if (nominalDependentNodeHash && nominalDependentNodeHash->getNominalDependentNodeData(nominalIndividual->getIndividualID())) {
CSaturationNominalDependentNodeData* nomDepNodeData = nominalDependentNodeHash->getNominalDependentNodeData(nominalIndividual->getIndividualID());
if (nomDepNodeData) {
// identify connections and save them as possibly/non-deterministic (existentially) instantiated roles
newAssWriteDataLinker->setIndirectlyConnectedNominalIndividual(true);
determineNominalIndividualIdPossiblyExistentialRoleInstantiatedSetLabelAssociationBackendItem(nominalIndividual->getIndividualID(), nomDepNodeData, newAssWriteDataLinker, calcAlgContext);
}
}
collectSaturationNodeSuccessorRelatedRoles(satNode->getIndividualID(), satNode, nullptr, nullptr, false, true, false, true, true, mNominalIndiIdRoleConnectionDataHash, nullptr, nullptr, nullptr, calcAlgContext);
CIndividualSaturationProcessNodeStatusFlags* indFlags = satNode->getIndirectStatusFlags();
CIndividualSaturationProcessNodeStatusFlags* dirFlags = satNode->getDirectStatusFlags();
bool insufficient = indFlags->hasInsufficientFlag() || !indFlags->hasCompletedFlag() || !dirFlags->hasCompletedFlag();
if (insufficient) {
newAssWriteDataLinker->setCompletelySaturated(false);
newAssWriteDataLinker->setCompletelyHandled(false);
}
newAssWriteDataLinker->setCompletelyPropagated(!dirFlags->hasPropagationIncompleteFlag());
if (indiLoadedAssocHash && indiLoadedAssocHash->contains(satNode->getIndividualID())) {
CIndividualRepresentativeBackendCacheLoadedAssociationData& assoLoadingData = (*indiLoadedAssocHash)[satNode->getIndividualID()];
assoLoadingData.setIndividualIntegrated(true);
}
if (!lastTmpAssWriteDataLinker) {
tmpAssWriteDataLinker = newAssWriteDataLinker;
lastTmpAssWriteDataLinker = tmpAssWriteDataLinker;
} else {
lastTmpAssWriteDataLinker->setNext(newAssWriteDataLinker);
lastTmpAssWriteDataLinker = newAssWriteDataLinker;
}
}
}
CIndividualSaturationProcessNodeLinker* nextIndiSaturationAnalysingNodeLinkerIt = indiSaturationAnalysingNodeLinker;
for (CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* newAssWriteDataLinker = tmpAssWriteDataLinker; newAssWriteDataLinker; newAssWriteDataLinker = newAssWriteDataLinker->getNext()) {
CIndividual* nominalIndividual = nullptr;
CIndividualSaturationProcessNode* satNode = nullptr;
while (!nominalIndividual) {
satNode = nextIndiSaturationAnalysingNodeLinkerIt->getProcessingIndividual();
nominalIndividual = satNode->getNominalIndividual();
nextIndiSaturationAnalysingNodeLinkerIt = nextIndiSaturationAnalysingNodeLinkerIt->getNext();
}
determineSaturationNodeIndividualCombinedNeighbourRoleInstantiatedSetLabelAssociationBackendItem(satNode, newAssWriteDataLinker, calcAlgContext);
determineSaturationNodeIndividualNeighbourRoleInstantiatedSetCompinationLabelAssociationBackendItem(satNode, newAssWriteDataLinker, calcAlgContext);
}
if (mNominalIndiIdRoleConnectionDataHash && !mNominalIndiIdRoleConnectionDataHash->isEmpty()) {
for (CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* >::const_iterator it = mNominalIndiIdRoleConnectionDataHash->constBegin(), itEnd = mNominalIndiIdRoleConnectionDataHash->constEnd(); it != itEnd; ++it) {
cint64 indiId = it.key();
CBackendRepresentativeMemoryCacheTemporaryNominalRoleConnectionData* nominalConnectionData = it.value();
CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* newAssWriteDataLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker >::allocateAndConstruct(mMemAllocMan);
newAssWriteDataLinker->initAccociationWriteData(indiId, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker::ADDITION, CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker::ADDITION);
determineNominalIndividualIdCombinedNeighbourRoleInstantiatedSetLabelAssociationBackendItem(indiId, nominalConnectionData, newAssWriteDataLinker, calcAlgContext);
determineNominalIndividualIdNeighbourRoleInstantiatedSetCompinationLabelAssociationBackendItem(indiId, nominalConnectionData, newAssWriteDataLinker, calcAlgContext);
if (indiLoadedAssocHash && indiLoadedAssocHash->contains(indiId)) {
CIndividualRepresentativeBackendCacheLoadedAssociationData& assoLoadingData = (*indiLoadedAssocHash)[indiId];
assoLoadingData.setIndividualIntegrated(true);
}
if (!lastTmpAssWriteDataLinker) {
tmpAssWriteDataLinker = newAssWriteDataLinker;
lastTmpAssWriteDataLinker = tmpAssWriteDataLinker;
} else {
lastTmpAssWriteDataLinker->setNext(newAssWriteDataLinker);
lastTmpAssWriteDataLinker = newAssWriteDataLinker;
}
}
}
CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* tempNomIndirectConnDataLinker = nullptr;
CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* lastTempNomIndirectConnDataLinker = nullptr;
for (CBackendRepresentativeMemoryCacheTemporaryAssociationWriteDataLinker* tmpAssWriteDataLinkerIt = tmpAssWriteDataLinker; tmpAssWriteDataLinkerIt; tmpAssWriteDataLinkerIt = tmpAssWriteDataLinkerIt->getNext()) {
cint64 indiId = tmpAssWriteDataLinkerIt->getData()->getIndividualID();
CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* nomIndiConnDataLinker = nominalIndirectConnectionUpdateDataLinkerHash->value(indiId);
if (nomIndiConnDataLinker) {
tmpAssWriteDataLinkerIt->setIndirectlyConnectedNominalIndividual(true);
if (tempNomIndirectConnDataLinker) {
lastTempNomIndirectConnDataLinker->setNext(nomIndiConnDataLinker);
lastTempNomIndirectConnDataLinker = nomIndiConnDataLinker;
} else {
tempNomIndirectConnDataLinker = nomIndiConnDataLinker;
lastTempNomIndirectConnDataLinker = nomIndiConnDataLinker;
}
nominalIndirectConnectionUpdateDataLinkerHash->remove(indiId);
}
}
for (CPROCESSHASH< cint64, CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* >::const_iterator it = nominalIndirectConnectionUpdateDataLinkerHash->constBegin(), itEnd = nominalIndirectConnectionUpdateDataLinkerHash->constEnd(); it != itEnd; ++it) {
cint64 nomIndiId = it.key();
CBackendRepresentativeMemoryCacheTemporaryNominalIndirectConnectionDataLinker* nomIndiConnDataLinker = it.value();
if (nomIndiConnDataLinker) {
if (tempNomIndirectConnDataLinker) {
lastTempNomIndirectConnDataLinker->setNext(nomIndiConnDataLinker);
lastTempNomIndirectConnDataLinker = nomIndiConnDataLinker;
} else {
tempNomIndirectConnDataLinker = nomIndiConnDataLinker;
lastTempNomIndirectConnDataLinker = nomIndiConnDataLinker;
}
}
}
if (indiLoadedAssocHash) {
for (CIndividualRepresentativeBackendCacheLoadedAssociationHash::const_iterator it = indiLoadedAssocHash->constBegin(), itEnd = indiLoadedAssocHash->constEnd(); it != itEnd; ++it) {
cint64 indiAssoId = it.key();
CIndividualRepresentativeBackendCacheLoadedAssociationData indiAssoLoadingData = it.value();
if (!indiAssoLoadingData.isIndividualIntegrated()) {
CBackendRepresentativeMemoryCacheTemporaryAssociationUseDataLinker* newTmpAssUseDataLinker = CObjectAllocator< CBackendRepresentativeMemoryCacheTemporaryAssociationUseDataLinker >::allocateAndConstruct(mMemAllocMan);
newTmpAssUseDataLinker->initAccociationUseData(indiAssoId);
newTmpAssUseDataLinker->setUsedAssociationUpdateId(indiAssoLoadingData.getLoadedIndividualAssociationData()->getAssociationDataUpdateId());
tmpAssUseDataLinker = newTmpAssUseDataLinker->append(tmpAssUseDataLinker);
}
}
}
CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* tempLabelWriteDataLinker = nullptr;
CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* lastTempLabelWriteDataLinker = nullptr;
for (CPROCESSLIST< CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* >::const_iterator it = mNewTmpLabelList->constBegin(), itEnd = mNewTmpLabelList->constEnd(); it != itEnd; ++it) {
CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* newTmpLabelLinker = (*it);
newTmpLabelLinker->clearNext();
if (!lastTempLabelWriteDataLinker) {
tempLabelWriteDataLinker = newTmpLabelLinker;
lastTempLabelWriteDataLinker = tempLabelWriteDataLinker;
} else {
lastTempLabelWriteDataLinker->setNext(newTmpLabelLinker);
lastTempLabelWriteDataLinker = newTmpLabelLinker;
}
}
CBackendRepresentativeMemoryCacheTemporaryCardinalityWriteDataLinker* tempCardWriteDataLinker = nullptr;
for (CPROCESSLIST< CBackendRepresentativeMemoryCacheTemporaryCardinalityWriteDataLinker* >::const_iterator it = mNewTmpCardList->constBegin(), itEnd = mNewTmpCardList->constEnd(); it != itEnd; ++it) {
CBackendRepresentativeMemoryCacheTemporaryCardinalityWriteDataLinker* newTmpCardLinker = (*it);
newTmpCardLinker->clearNext();
tempCardWriteDataLinker = newTmpCardLinker->append(tempCardWriteDataLinker);
}
cint64 ontologyIdentifier = calcAlgContext->getProcessingDataBox()->getOntology()->getOntologyID();
cint64 repCompId = -1;
if (repbackUpdAdapter) {
repCompId = repbackUpdAdapter->getRepresentativeCacheRecomputationId();
}
CBackendRepresentativeMemoryCacheLabelAssociationWriteData* writeData = CObjectAllocator< CBackendRepresentativeMemoryCacheLabelAssociationWriteData >::allocateAndConstruct(mMemAllocMan);
writeData->initWriteData(ontologyIdentifier, tmpAssWriteDataLinker, tempNomIndirectConnDataLinker, tmpAssUseDataLinker, tempLabelWriteDataLinker,tempCardWriteDataLinker, nullptr, nullptr, repCompId);
addCacheMessages(writeData,calcAlgContext);
commitCacheMessages(calcAlgContext);
return false;
}
}; // end namespace Algorithm
}; // end namespace Kernel
}; // end namespace Reasoner
}; // end namespace Konclude