/* * 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 "CBackendRepresentativeMemoryCacheUtilities.h" namespace Konclude { namespace Reasoner { namespace Kernel { namespace Cache { CBackendRepresentativeMemoryCacheUtilities::CBackendRepresentativeMemoryCacheUtilities() { } cint64 CBackendRepresentativeMemoryCacheUtilities::getConceptDescriptorSignature(CConceptSaturationDescriptor* conDesLinker, cint64 count, CConcept* exclusionConcept) { cint64 sigValue = 0; for (CConceptSaturationDescriptor* conDesLinkerIt = conDesLinker; conDesLinkerIt; conDesLinkerIt = conDesLinkerIt->getNext()) { CConcept* concept = conDesLinkerIt->getConcept(); bool negated = conDesLinkerIt->isNegated(); if (negated || concept != exclusionConcept) { cint64 tag = concept->getConceptTag(); if (negated) { tag = -tag; } sigValue += qHash((cint64)tag); } } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getConceptDescriptorSignature(CConceptDescriptor* conDesLinker, cint64& count, bool deterministic, cint64 maxDeterministicBranchTag, bool excludePositiveNominalConcepts) { cint64 sigValue = 0; count = 0; for (CConceptDescriptor* conDesLinkerIt = conDesLinker; conDesLinkerIt; conDesLinkerIt = conDesLinkerIt->getNext()) { CConcept* concept = conDesLinkerIt->getConcept(); bool negated = conDesLinkerIt->isNegated(); bool deterministicallyDerived = true; if (!conDesLinkerIt->getDependencyTrackPoint() || conDesLinkerIt->getDependencyTrackPoint()->getBranchingTag() > maxDeterministicBranchTag) { deterministicallyDerived = false; } bool considerConcept = deterministicallyDerived == deterministic; if (excludePositiveNominalConcepts && concept->getOperatorCode() == CCNOMINAL && !negated) { considerConcept = false; } if (considerConcept) { cint64 tag = concept->getConceptTag(); if (negated) { tag = -tag; } sigValue += qHash((cint64)tag); ++count; } } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getIndividualSetSignature(cint64 indiId, CIndividualMergingHash* indiMerginghash, cint64& count, bool onlyDeterministic, cint64 maxDeterministicBranchTag) { cint64 sigValue = 0; count = 0; for (CIndividualMergingHash::const_iterator it = indiMerginghash->constBegin(), itEnd = indiMerginghash->constEnd(); it != itEnd; ++it) { cint64 mergedIndiId = it.key(); if (mergedIndiId != indiId && it.value().isMergedWithIndividual()) { CIndividualMergingHashData mergedData = it.value(); bool deterministicallyDerived = true; if (!mergedData.getDependencyTrackPoint() || mergedData.getDependencyTrackPoint()->getBranchingTag() > maxDeterministicBranchTag) { deterministicallyDerived = false; } bool considerIndividual = deterministicallyDerived || !onlyDeterministic; if (considerIndividual) { cint64 tag = mergedIndiId; sigValue += qHash((cint64)tag); ++count; } } } if (count > 0 && indiId >= 0) { sigValue += qHash((cint64)indiId); ++count; } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getIndividualSetSignature(cint64 indiId, CDistinctHash* indiDistinctHash, cint64& count, bool onlyDeterministic, cint64 maxDeterministicBranchTag) { cint64 sigValue = 0; count = 0; 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) { cint64 tag = distinctIndiId; sigValue += qHash((cint64)tag); ++count; } } } if (count > 0 && indiId >= 0) { sigValue += qHash((cint64)indiId); ++count; } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getIndividualSetSignature(CPROCESSSET* individualSet, cint64& count) { cint64 sigValue = 0; count = 0; for (CPROCESSSET::const_iterator it = individualSet->constBegin(), itEnd = individualSet->constEnd(); it != itEnd; ++it) { cint64 indiId = *it; sigValue += qHash((cint64)indiId); ++count; } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getConceptDescriptorSignature(CConceptDescriptor* conDesLinker, cint64& count, function exclusionDetermineFunction) { cint64 sigValue = 0; count = 0; for (CConceptDescriptor* conDesLinkerIt = conDesLinker; conDesLinkerIt; conDesLinkerIt = conDesLinkerIt->getNext()) { CConcept* concept = conDesLinkerIt->getConcept(); bool negated = conDesLinkerIt->isNegated(); bool considerConcept = exclusionDetermineFunction(concept, negated); if (considerConcept) { cint64 tag = concept->getConceptTag(); if (negated) { tag = -tag; } sigValue += qHash((cint64)tag); ++count; } } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getConceptDescriptorSignature(CConceptDescriptor* conDesLinker, cint64& count, function exclusionDetermineFunction, function deterministicDetermineFunction) { cint64 sigValue = 0; count = 0; for (CConceptDescriptor* conDesLinkerIt = conDesLinker; conDesLinkerIt; conDesLinkerIt = conDesLinkerIt->getNext()) { CConcept* concept = conDesLinkerIt->getConcept(); bool negated = conDesLinkerIt->isNegated(); bool considerConcept = exclusionDetermineFunction(concept, negated); if (considerConcept) { bool deterministic = deterministicDetermineFunction(concept, negated, conDesLinkerIt->getDependencyTrackPoint()); cint64 tag = concept->getConceptTag(); if (negated) { tag = -tag; } sigValue += qHash((cint64)tag); ++count; } } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getRoleInversedLinkerSignature(CSortedNegLinker* roleLinker, bool inversed, cint64 count) { cint64 sigValue = 0; for (CSortedNegLinker* roleLinkerIt = roleLinker; roleLinkerIt; roleLinkerIt = roleLinkerIt->getNext()) { CRole* role = roleLinkerIt->getData(); bool roleInversed = roleLinkerIt->isNegated() ^ inversed; cint64 tag = role->getRoleTag(); if (roleInversed) { tag = -tag; } sigValue += qHash((cint64)tag); } return sigValue; } cint64 CBackendRepresentativeMemoryCacheUtilities::getNeighbourRoleInstantiatedSetLinkerSignature(CBackendRepresentativeMemoryCacheTemporaryLabelReferenceDataLinker* neighbourRoleSetLinker, cint64 count) { cint64 signature = 0; for (CBackendRepresentativeMemoryCacheTemporaryLabelReferenceDataLinker* neighbourRoleSetLinkerIt = neighbourRoleSetLinker; neighbourRoleSetLinkerIt; neighbourRoleSetLinkerIt = neighbourRoleSetLinkerIt->getNext()) { CBackendRepresentativeMemoryLabelCacheItem* labelCacheItem = neighbourRoleSetLinkerIt->getReferredLabelData(); CBackendRepresentativeMemoryCacheTemporaryLabelWriteDataLinker* tmpLabelWriteData = neighbourRoleSetLinkerIt->getReferredTemporaryLabelData(); cint64 value = 0; if (tmpLabelWriteData) { value = (cint64)tmpLabelWriteData; } else { value = (cint64)labelCacheItem->getCacheEntryID(); } signature += qHash((qint64)value); } return signature; } cint64 CBackendRepresentativeMemoryCacheUtilities::getSignatureExtensionByCacheValue(cint64 signature, CCacheValue& cacheValue) { signature += qHash((qint64)cacheValue.getTag()); return signature; } }; // end namespace Cache }; // end namespace Kernel }; // end namespace Reasoner }; // end namespace Konclude