| 1 |
/* |
| 2 |
* Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. |
| 3 |
* |
| 4 |
* This file is part of the reasoning system Konclude. |
| 5 |
* For details and support, see <http://konclude.com/>. |
| 6 |
* |
| 7 |
* Konclude is free software: you can redistribute it and/or modify |
| 8 |
* it under the terms of version 3 of the GNU Lesser General Public |
| 9 |
* License (LGPLv3) as published by the Free Software Foundation. |
| 10 |
* |
| 11 |
* Konclude is distributed in the hope that it will be useful, |
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 |
* GNU (Lesser) General Public License for more details. |
| 15 |
* |
| 16 |
* You should have received a copy of the GNU (Lesser) General Public |
| 17 |
* License along with Konclude. If not, see <http://www.gnu.org/licenses/>. |
| 18 |
* |
| 19 |
*/ |
| 20 |
|
| 21 |
#ifndef KONCLUDE_REASONER_KERNEL_ALGORITHM_CCALCULATIONTABLEAUCOMPLETIONTASKHANDLEALGORITHM_H |
| 22 |
#define KONCLUDE_REASONER_KERNEL_ALGORITHM_CCALCULATIONTABLEAUCOMPLETIONTASKHANDLEALGORITHM_H |
| 23 |
|
| 24 |
// Libraries includes |
| 25 |
|
| 26 |
|
| 27 |
// Namespace includes |
| 28 |
#include "AlgorithmSettings.h" |
| 29 |
#include "CCalculationAlgorithmContextBase.h" |
| 30 |
#include "CCalculationStopProcessingException.h" |
| 31 |
#include "CCalculationErrorProcessingException.h" |
| 32 |
#include "CCalculationClashProcessingException.h" |
| 33 |
#include "CSatisfiableTaskConsistencyPreyingAnalyser.h" |
| 34 |
#include "CSatisfiableTaskIncrementalConsistencyPreyingAnalyser.h" |
| 35 |
#include "CSatisfiableTaskClassificationMessageAnalyser.h" |
| 36 |
#include "CSatisfiableTaskMarkerIndividualPropagationAnalyser.h" |
| 37 |
#include "CTrackedClashedDependencyLine.h" |
| 38 |
#include "CTrackedClashedDescriptor.h" |
| 39 |
#include "CTrackedClashedDescriptorHasher.h" |
| 40 |
#include "CDependencyFactory.h" |
| 41 |
#include "CClashDescriptorFactory.h" |
| 42 |
#include "CIndividualNodeManager.h" |
| 43 |
#include "CUnsatisfiableCacheHandler.h" |
| 44 |
#include "CSatisfiableExpanderCacheHandler.h" |
| 45 |
#include "CReuseCompletionGraphCacheHandler.h" |
| 46 |
#include "CCompletionGraphCacheHandler.h" |
| 47 |
#include "CConceptNominalSchemaGroundingHandler.h" |
| 48 |
#include "CSaturationNodeExpansionCacheHandler.h" |
| 49 |
#include "CDatatypeIndividualProcessNodeHandler.h" |
| 50 |
#include "CComputedConsequencesCacheHandler.h" |
| 51 |
#include "CIndividualNodeBackendCacheHandler.h" |
| 52 |
#include "COccurrenceStatisticsCacheHandler.h" |
| 53 |
#include "CIncrementalCompletionGraphCompatibleExpansionHandler.h" |
| 54 |
#include "CSatisfiableTaskPossibleAssertionCollectingAnalyser.h" |
| 55 |
#include "CSatisfiableTaskPropertyClassificationMessageAnalyser.h" |
| 56 |
#include "CSatisfiableTaskComplexAnsweringMessageAnalyser.h" |
| 57 |
#include "CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser.h" |
| 58 |
#include "CIndexedIndividualAssertionConvertionVisitor.h" |
| 59 |
|
| 60 |
// Other includes |
| 61 |
#include "Reasoner/Kernel/Task/CSatisfiableCalculationTask.h" |
| 62 |
#include "Reasoner/Kernel/Task/CCalculationConfigurationExtension.h" |
| 63 |
|
| 64 |
#include "Reasoner/Kernel/Process/CIndividualProcessNode.h" |
| 65 |
#include "Reasoner/Kernel/Process/CConceptProcessDescriptor.h" |
| 66 |
#include "Reasoner/Kernel/Process/CConceptProcessingQueue.h" |
| 67 |
#include "Reasoner/Kernel/Process/CLinkProcessingRestrictionSpecification.h" |
| 68 |
#include "Reasoner/Kernel/Process/CBranchingORProcessingRestrictionSpecification.h" |
| 69 |
#include "Reasoner/Kernel/Process/CBranchingMergingProcessingRestrictionSpecification.h" |
| 70 |
#include "Reasoner/Kernel/Process/CTriggeredImplicationProcessingRestrictionSpecification.h" |
| 71 |
#include "Reasoner/Kernel/Process/CIndividualNodeBlockingTestData.h" |
| 72 |
#include "Reasoner/Kernel/Process/CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData.h" |
| 73 |
|
| 74 |
#include "Reasoner/Kernel/Process/CClashedConceptDescriptor.h" |
| 75 |
#include "Reasoner/Kernel/Process/CClashedIndividualLinkDescriptor.h" |
| 76 |
#include "Reasoner/Kernel/Process/CClashedIndividualDistinctDescriptor.h" |
| 77 |
#include "Reasoner/Kernel/Process/CClashedNegationDisjointLinkDescriptor.h" |
| 78 |
|
| 79 |
#include "Reasoner/Kernel/Process/CBlockingAlternativeData.h" |
| 80 |
#include "Reasoner/Kernel/Process/CBlockingAlternativeSignatureBlockingCandidateData.h" |
| 81 |
#include "Reasoner/Kernel/Process/CExtendedCondensedReapplyConceptDescriptorATMOSTReactivation.h" |
| 82 |
|
| 83 |
#include "Reasoner/Kernel/Process/CBranchingInstructionAddIndividualConcepts.h" |
| 84 |
|
| 85 |
#include "Reasoner/Kernel/Process/Dependency/CANDDependencyNode.h" |
| 86 |
#include "Reasoner/Kernel/Process/Dependency/CSOMEDependencyNode.h" |
| 87 |
#include "Reasoner/Kernel/Process/Dependency/CVALUEDependencyNode.h" |
| 88 |
#include "Reasoner/Kernel/Process/Dependency/CNEGVALUEDependencyNode.h" |
| 89 |
#include "Reasoner/Kernel/Process/Dependency/CALLDependencyNode.h" |
| 90 |
#include "Reasoner/Kernel/Process/Dependency/CATLEASTDependencyNode.h" |
| 91 |
#include "Reasoner/Kernel/Process/Dependency/CORDependencyNode.h" |
| 92 |
#include "Reasoner/Kernel/Process/Dependency/CAUTOMATTRANSACTIONDependencyNode.h" |
| 93 |
#include "Reasoner/Kernel/Process/Dependency/CAUTOMATCHOOSEDependencyNode.h" |
| 94 |
#include "Reasoner/Kernel/Process/Dependency/CSELFDependencyNode.h" |
| 95 |
#include "Reasoner/Kernel/Process/Dependency/CDISTINCTDependencyNode.h" |
| 96 |
#include "Reasoner/Kernel/Process/Dependency/CNOMINALDependencyNode.h" |
| 97 |
#include "Reasoner/Kernel/Process/Dependency/CFUNCTIONALDependencyNode.h" |
| 98 |
#include "Reasoner/Kernel/Process/Dependency/CATMOSTDependencyNode.h" |
| 99 |
#include "Reasoner/Kernel/Process/Dependency/CMERGEDependencyNode.h" |
| 100 |
#include "Reasoner/Kernel/Process/Dependency/CQUALIFYDependencyNode.h" |
| 101 |
#include "Reasoner/Kernel/Process/Dependency/CMERGEDCONCEPTDependencyNode.h" |
| 102 |
#include "Reasoner/Kernel/Process/Dependency/CMERGEDLINKDependencyNode.h" |
| 103 |
#include "Reasoner/Kernel/Process/Dependency/CIMPLICATIONDependencyNode.h" |
| 104 |
#include "Reasoner/Kernel/Process/Dependency/CCONNECTIONDependencyNode.h" |
| 105 |
#include "Reasoner/Kernel/Process/Dependency/CREUSEINDIVIDUALDependencyNode.h" |
| 106 |
#include "Reasoner/Kernel/Process/Dependency/CREUSECONCEPTSDependencyNode.h" |
| 107 |
#include "Reasoner/Kernel/Process/Dependency/CREUSECOMPLETIONGRAPHDependencyNode.h" |
| 108 |
#include "Reasoner/Kernel/Process/Dependency/CORDisjunctDependencyTrackPoint.h" |
| 109 |
#include "Reasoner/Kernel/Process/Dependency/CMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode.h" |
| 110 |
|
| 111 |
|
| 112 |
#include "Reasoner/Kernel/Strategy/CConceptProcessingPriorityStrategy.h" |
| 113 |
#include "Reasoner/Kernel/Strategy/CIndividualProcessingPriorityStrategy.h" |
| 114 |
#include "Reasoner/Kernel/Strategy/CTaskProcessingPriorityStrategy.h" |
| 115 |
#include "Reasoner/Kernel/Strategy/CEqualDepthCacheOrientatedProcessingPriorityStrategy.h" |
| 116 |
#include "Reasoner/Kernel/Strategy/CConcreteConceptProcessingOperatorPriorityStrategy.h" |
| 117 |
#include "Reasoner/Kernel/Strategy/CIndividualAncestorDepthMaximumConceptProcessingPriorityStrategy.h" |
| 118 |
#include "Reasoner/Kernel/Strategy/CEqualDepthTaskProcessingPriorityStrategy.h" |
| 119 |
#include "Reasoner/Kernel/Strategy/CGenerativeNonDeterministicUnsatisfiableCacheRetrievalStrategy.h" |
| 120 |
|
| 121 |
#include "Reasoner/Kernel/Process/Dependency/CDependencyTrackPoint.h" |
| 122 |
|
| 123 |
#include "Reasoner/Kernel/Cache/CExpanderBranchedLinker.h" |
| 124 |
#include "Reasoner/Kernel/Cache/CSignatureSatisfiableExpanderCacheEntry.h" |
| 125 |
|
| 126 |
#include "Scheduler/CTask.h" |
| 127 |
#include "Scheduler/CTaskHandleAlgorithm.h" |
| 128 |
|
| 129 |
#include "Reasoner/Ontology/CConceptProcessData.h" |
| 130 |
#include "Reasoner/Ontology/CConceptTextFormater.h" |
| 131 |
#include "Reasoner/Ontology/CDisjunctionBranchingStatistics.h" |
| 132 |
#include "Reasoner/Ontology/CConceptNegationPair.h" |
| 133 |
|
| 134 |
#include "Utilities/Memory/CObjectMemoryPoolAllocator.h" |
| 135 |
#include "Utilities/Memory/CMemoryAllocationException.h" |
| 136 |
|
| 137 |
|
| 138 |
#include "Test/CCompletionGraphRandomWalkQueryGenerator.h" |
| 139 |
|
| 140 |
// Logger includes |
| 141 |
#include "Logger/CLogger.h" |
| 142 |
|
| 143 |
|
| 144 |
|
| 145 |
namespace Konclude { |
| 146 |
|
| 147 |
//using namespace Test; |
| 148 |
using namespace Scheduler; |
| 149 |
using namespace Utilities::Memory; |
| 150 |
|
| 151 |
namespace Reasoner { |
| 152 |
|
| 153 |
namespace Kernel { |
| 154 |
|
| 155 |
using namespace Process; |
| 156 |
using namespace Process::Dependency; |
| 157 |
using namespace Task; |
| 158 |
using namespace Strategy; |
| 159 |
using namespace Cache; |
| 160 |
|
| 161 |
namespace Algorithm { |
| 162 |
|
| 163 |
|
| 164 |
/*! |
| 165 |
* |
| 166 |
* \class CCalculationTableauCompletionTaskHandleAlgorithm |
| 167 |
* \author Andreas Steigmiller |
| 168 |
* \version 0.1 |
| 169 |
* \brief TODO |
| 170 |
* |
| 171 |
*/ |
| 172 |
class CCalculationTableauCompletionTaskHandleAlgorithm : public CTaskHandleAlgorithm { |
| 173 |
// public methods |
| 174 |
public: |
| 175 |
//! Constructor |
| 176 |
CCalculationTableauCompletionTaskHandleAlgorithm(CUnsatisfiableCacheHandler* unsatCacheHandler, CSatisfiableExpanderCacheHandler* satExpCacheHandler, CReuseCompletionGraphCacheHandler* reuseCompGraphCacheHandler, CSaturationNodeExpansionCacheHandler* satNodeExpCacheHandler, CComputedConsequencesCacheHandler* compConsCacheHandler, CIndividualNodeBackendCacheHandler* backendCacheHandler, COccurrenceStatisticsCacheHandler* occStatsCacheHandler); |
| 177 |
|
| 178 |
//! Destructor |
| 179 |
virtual ~CCalculationTableauCompletionTaskHandleAlgorithm(); |
| 180 |
|
| 181 |
virtual bool handleTask(CTaskProcessorContext *processorContext, CTask* task); |
| 182 |
|
| 183 |
void readCalculationConfig(CSatisfiableCalculationTask* satCalcTask); |
| 184 |
|
| 185 |
|
| 186 |
cint64 getAppliedANDRuleCount(); |
| 187 |
cint64 getAppliedORRuleCount(); |
| 188 |
cint64 getAppliedSOMERuleCount(); |
| 189 |
cint64 getAppliedATLEASTRuleCount(); |
| 190 |
cint64 getAppliedALLRuleCount(); |
| 191 |
cint64 getAppliedATMOSTRuleCount(); |
| 192 |
cint64 getAppliedTotalRuleCount(); |
| 193 |
|
| 194 |
|
| 195 |
// protected methods |
| 196 |
protected: |
| 197 |
typedef void (CCalculationTableauCompletionTaskHandleAlgorithm::*TableauRuleFunction) (CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 198 |
|
| 199 |
bool areAllDependentFactsUnchanged(CIndividualProcessNode* individualNode, CIndividualProcessNode* backtrackedIndividualNode, CDependencyTrackPoint* prevConDepTrackPoint, CIndividualProcessNodeVector* prevIndiNodeVec, cint64& remBacktrackCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 200 |
|
| 201 |
bool initializeIncrementalIndividualExpansion(CIndividualProcessNode* individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 202 |
CIndividual* getNextIncrementalExpansionIndividual(CIndividualProcessNode* individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 203 |
CIndividualProcessNode* incrementalNodeExpansion(CIndividualProcessNode* expandNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 204 |
bool requiresIncrementalNodeExpansion(CIndividualProcessNode* individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 205 |
|
| 206 |
|
| 207 |
|
| 208 |
bool incrementalMergeWithPreviousNondeterministicCompletionGraph(CCalculationAlgorithmContextBase* calcAlgContext); |
| 209 |
|
| 210 |
|
| 211 |
|
| 212 |
bool incrementalMergeWithPreviousDeterministicCompletionGraph(CCalculationAlgorithmContextBase* calcAlgContext); |
| 213 |
void pruneIncrementalRemovedSuccessors(CIndividualProcessNode*& indi, CPROCESSINGSET<cint64>* compatibleNominalNodeSet, CPROCESSINGSET<cint64>* pruningNodeSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 214 |
bool identifyCompatibilityChangedNominalIndividualNodes(CPROCESSINGSET<cint64>* nonCompatibleChangedNominalNodeSet, CPROCESSINGSET<cint64>* compatibleNominalNodeSet, CPROCESSINGSET<cint64>* redundantNodeSet, CPROCESSINGSET<cint64>* newNodeSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 215 |
bool checkCompatibilityUpdateDirectlyChangedPropagation(CIndividualProcessNode* individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 216 |
|
| 217 |
bool propagateDirectlyChangedNeighbourNodeConnection(CIndividualProcessNode* individualNode, bool queueIncrementalExpansion, CCalculationAlgorithmContextBase* calcAlgContext); |
| 218 |
bool establishDirectlyChangedNeighbourConnection(CIndividualProcessNode* individualNode, CIndividualProcessNode* neighbourNodeCandidate, bool queueIncrementalExpansion, CCalculationAlgorithmContextBase* calcAlgContext); |
| 219 |
CIndividualProcessNode* searchDirectlyChangedNeighbourNodeConnection(CIndividualProcessNode* individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 220 |
bool clearDirectlyChangedNeighbourConnection(CIndividualProcessNode* individualNode, bool queueCompatibilityChecks, CCalculationAlgorithmContextBase* calcAlgContext); |
| 221 |
bool clearPropagatedDirectlyChangedNeighbourConnection(CIndividualProcessNode* individualNode, bool queueCompatibilityChecks, CCalculationAlgorithmContextBase* calcAlgContext); |
| 222 |
bool linkCreationDirectlyChangedNeighbourConnectionUpdate(CIndividualProcessNode* sourceIndi, CIndividualProcessNode* destIndi, bool queueIncrementalExpansion, CCalculationAlgorithmContextBase* calcAlgContext); |
| 223 |
|
| 224 |
|
| 225 |
|
| 226 |
|
| 227 |
bool findNextPossibleInstanceMergingIndividual(CIndividualProcessNode* processIndi, CPossibleInstancesIndividualsMergingData* possInstanceMergingData, CCalculationAlgorithmContextBase* calcAlgContext, CPROCESSHASH<CBackendRepresentativeMemoryLabelCacheItem*, bool>*& testConceptLabelSetHash, CIndividualProcessNode** foundMergingIndiNode = nullptr, cint64* foundMergingIndiId = nullptr, bool* ruleApplicationFreeMerging = nullptr); |
| 228 |
bool findNextPossibleInstanceMergingIndividual(CIndividualProcessNode* processIndi, CPossibleInstancesIndividualsMergingData* possInstanceMergingData, CCalculationAlgorithmContextBase* calcAlgContext, CPROCESSHASH<CBackendRepresentativeMemoryLabelCacheItem*, bool>*& testConceptLabelSetHash, cint64 individualMaxMergingAttemptCount, CIndividualProcessNode** foundMergingIndiNode = nullptr, cint64* foundMergingIndiId = nullptr, bool* ruleApplicationFreeMerging = nullptr); |
| 229 |
bool tryPossibleInstanceMerging(CIndividualProcessNode* processIndi, CPossibleInstancesIndividualsMergingData* possInstanceMergingData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 230 |
|
| 231 |
|
| 232 |
|
| 233 |
|
| 234 |
|
| 235 |
|
| 236 |
bool trackIndividualReferredDependence(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 237 |
bool trackIndividualExtendedDependence(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 238 |
bool trackIndividualDependence(cint64 indiID, bool indiReferred, bool indiExtended, CCalculationAlgorithmContextBase* calcAlgContext); |
| 239 |
|
| 240 |
|
| 241 |
|
| 242 |
|
| 243 |
|
| 244 |
|
| 245 |
|
| 246 |
|
| 247 |
|
| 248 |
bool installSaturationCachingReactivation(CIndividualProcessNode* indiProcNode, CSaturationNodeAssociatedDependentNominalSet* nominalSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 249 |
bool tryInstallSaturationCachingReactivation(CIndividualProcessNode* indiProcNode, CSuccessorConnectedNominalSet* nominalSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 250 |
bool reactivateIndividualNodesDueToNominalCachingLoss(CIndividualProcessNode* nominalProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 251 |
|
| 252 |
bool checkIndividualNodesReactivationDueToNominalCachingLoss(CIndividualProcessNode* nominalProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 253 |
|
| 254 |
|
| 255 |
|
| 256 |
|
| 257 |
bool addCachedComputedTypes(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 258 |
|
| 259 |
|
| 260 |
|
| 261 |
|
| 262 |
|
| 263 |
|
| 264 |
bool isIndividualNodeBackendCacheSynchronizationProcessingBlocked(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 265 |
bool detectIndividualNodeBackendCacheSynchronized(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 266 |
|
| 267 |
|
| 268 |
|
| 269 |
|
| 270 |
|
| 271 |
CIndividualProcessNode* takeNextProcessIndividual(CCalculationAlgorithmContextBase* calcAlgContext); |
| 272 |
|
| 273 |
|
| 274 |
|
| 275 |
bool ensurePropagationCutLinksToExpandedIndividual(CIndividualProcessNode* propCutIndiNode, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locPropCutIndiBackendSyncData, CBackendNeighbourExpansionQueueDataLinker* backendNeighbourExpDataLinker, cint64 neighbourIndiId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 276 |
|
| 277 |
bool continueIndividualProcessing(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 278 |
|
| 279 |
bool tableauRuleProcessing(CIndividualProcessNode*& indiProcNode,CConceptProcessDescriptor*& conProcDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 280 |
bool individualNodeInitializing(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 281 |
void individualNodeConclusion(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 282 |
void tableauRuleChoice(CIndividualProcessNode*& indiProcNode, CConceptProcessDescriptor*& conProcDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 283 |
bool initialNodeInitialize(CIndividualProcessNode*& indiProcNode, bool allowPreprocess, CCalculationAlgorithmContextBase* calcAlgContext); |
| 284 |
|
| 285 |
void eliminiateBlockedIndividuals(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 286 |
|
| 287 |
bool isIndividualNodeCompletionGraphCached(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 288 |
bool detectIndividualNodeCompletionGraphCached(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 289 |
void clearCompletionGraphCaching(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 290 |
|
| 291 |
|
| 292 |
bool isIndividualNodeValidBlocker(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 293 |
|
| 294 |
|
| 295 |
bool rootUnsatisfiabilityWriteCaches(CSatisfiableCalculationTask* task, CCalculationAlgorithmContextBase* calcAlgContext); |
| 296 |
|
| 297 |
|
| 298 |
void clashedBacktracking(CClashedDependencyDescriptor* clashes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 299 |
bool cancellationRootTask(CCalculationAlgorithmContextBase* calcAlgContext); |
| 300 |
bool cancellationTask(CSatisfiableCalculationTask* task, CCalculationAlgorithmContextBase* calcAlgContext); |
| 301 |
CTrackedClashedDescriptor* getFreeTrackedClashedDescriptor(CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 302 |
bool backtrackFromTrackingLine(CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 303 |
bool backtrackFromTrackingLineStep(CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 304 |
bool backtrackNonDeterministicBranchingClashedDescriptorFromCurrentIndividualNodeLevel(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 305 |
bool backtrackNonDeterministicBranchingClashedDescriptorFromPreviousIndividualNodeLevel(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 306 |
bool backtrackNonDeterministicBranchingClashedDescriptor(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 307 |
CTrackedClashedDescriptor* getCollectedFilteredClashedDescriptorsFromBranch(CTrackedClashedDescriptor* nonDetClashedPointingDes, CNonDeterministicDependencyNode* nonDetBranchDepNode, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext, CMemoryAllocationManager* tmpMemMan = nullptr); |
| 308 |
bool backtrackDeterministicBranchingClashedDescriptorFromCurrentIndividualNodeLevel(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 309 |
bool backtrackDeterministicClashedDescriptorFromPreviousIndividualNodeLevels(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 310 |
CTrackedClashedDescriptor* getBacktrackedDeterministicClashedDescriptorsBeforeProcessingTag(CTrackedClashedDescriptor* trackedClashedDescriptors, cint64 processingTag, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 311 |
CTrackedClashedDescriptor* getBacktrackedDeterministicClashedDescriptors(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, cint64* minIndiLevel, CCalculationAlgorithmContextBase* calcAlgContext); |
| 312 |
CTrackedClashedDescriptor* tryGetInvalidSameIndividualNodeLevelBacktrackedDeterministicClashedDescriptors(CTrackedClashedDescriptor* trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, cint64* minIndiLevel, CCalculationAlgorithmContextBase* calcAlgContext); |
| 313 |
bool initializeTrackingLine(CTrackedClashedDependencyLine* trackingLine, CTrackedClashedDescriptor* trackingClashes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 314 |
CTrackedClashedDescriptor* createTrackedClashesDescriptors(CClashedDependencyDescriptor* clashes, CCalculationAlgorithmContextBase* calcAlgContext, CMemoryAllocationManager* tmpMemMan = nullptr, bool copyIndependentConceptDescriptors = false); |
| 315 |
CTrackedClashedDescriptor* createTrackedClashesDescriptor(CClashedDependencyDescriptor* clashDes, CCalculationAlgorithmContextBase* calcAlgContext, CMemoryAllocationManager* tmpMemMan = nullptr, bool copyIndependentConceptDescriptors = false); |
| 316 |
CIndividualProcessNode* getCoresspondingIndividualNodeFromDependency(CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 317 |
CIndividualProcessNode* getCoresspondingIndividualNodeFromDependency(CDependencyNode* depNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 318 |
|
| 319 |
bool isGeneratingConceptSatisfiableCachedAbsorpable(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 320 |
|
| 321 |
bool reapplySatisfiableCachedAbsorbedGeneratingConcepts(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 322 |
bool reapplySatisfiableCachedAbsorbedDisjunctionConcepts(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 323 |
|
| 324 |
|
| 325 |
void checkValueSpaceDistinctSatisfiability(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 326 |
void triggerValueSpaceConcepts(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 327 |
void addtriggeredValueSpaceConcepts(CIndividualProcessNode* processIndi, CConceptDescriptor* triggeredConceptLinker, CCalculationAlgorithmContextBase* calcAlgContext); |
| 328 |
|
| 329 |
|
| 330 |
void tryCompletionGraphReuse(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 331 |
|
| 332 |
|
| 333 |
|
| 334 |
void upgradeSignatureBlockingToIndividualReusing(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 335 |
void establishIndividualReusing(CIndividualProcessNode* processIndi, CIndividualProcessNode* reuseIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 336 |
void updateIndividualReusing(CIndividualProcessNode* processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 337 |
CIndividualProcessNode* searchSignatureReusingIndividualNode(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 338 |
bool hasCompatibleConceptSetReuse(CIndividualProcessNode* indiNode, CReapplyConceptLabelSet* subConceptSet, CIndividualProcessNode* reuseNodeCand, CCalculationAlgorithmContextBase* calcAlgContext); |
| 339 |
bool addReusingBlockerFollowing(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 340 |
bool removeReusingBlockerFollowing(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 341 |
void propagateIndirectSuccessorReuseBlocked(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 342 |
void reactivateIndirectReuseSuccessors(CIndividualProcessNode*& indi, bool recursive, CCalculationAlgorithmContextBase* calcAlgContext); |
| 343 |
void removeIndividualReusing(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 344 |
|
| 345 |
|
| 346 |
bool anlyzeIndiviudalNodesConceptExpansion(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 347 |
bool isConceptFromDirectOrPredecessorOrNondeterminismusDependent(CIndividualProcessNode*& individualNode, CConceptDescriptor* conDes, CDependencyTrackPoint* depTrackPoint, bool* directDependentFlag, CCalculationAlgorithmContextBase* calcAlgContext); |
| 348 |
bool isConceptSignatureBlockingCritical(CIndividualProcessNode*& individualNode, CConceptDescriptor* conDes, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 349 |
bool getConceptDependenciesToSameIndividualNode(CIndividualProcessNode*& individualNode, CConceptDescriptor* conDes, CDependencyTrackPoint* depTrackPoint, CXLinker<CConceptDescriptor*>*& depLinker, CCalculationAlgorithmContextBase* calcAlgContext); |
| 350 |
|
| 351 |
bool hasCompatibleConceptSetSignature(CIndividualProcessNode*& blockingNode, CReapplyConceptLabelSet* conSet, CIndividualProcessNode* compatibleTestNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 352 |
bool detectIndividualNodeSignatureBlockingStatus(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 353 |
bool isSignatureBlockedProcessingBlocked(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 354 |
|
| 355 |
bool establishIndividualNodeSignatureBlocking(CIndividualProcessNode*& blockingIndividualNode, CIndividualProcessNode*& blockerIndividualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 356 |
bool refreshIndividualNodeSignatureBlocking(CIndividualProcessNode*& blockingIndividualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 357 |
bool updateSignatureBlockingConceptExpansion(CIndividualProcessNode*& blockingIndividualNode, CSignatureBlockingIndividualNodeConceptExpansionData* sigBlockingData, CIndividualProcessNode*& blockerIndividualNode, CIndividualNodeAnalizedConceptExpansionData* blockerAnalizedConExpData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 358 |
|
| 359 |
bool removeSignatureBlockingBlockerFollowing(CIndividualProcessNode*& blockingIndividualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 360 |
bool addSignatureBlockingBlockerFollowing(CIndividualProcessNode*& blockingIndividualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 361 |
void rebuildSignatureBlockingCandidateHash(CCalculationAlgorithmContextBase* calcAlgContext); |
| 362 |
|
| 363 |
void propagateIndirectSuccessorSignatureBlocked(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 364 |
void reactivateIndirectSignatureBlockedSuccessors(CIndividualProcessNode*& indi, bool recursive, CCalculationAlgorithmContextBase* calcAlgContext); |
| 365 |
|
| 366 |
bool updateBlockingReviewMarking(CIndividualProcessNode*& blockingIndividualNode, bool isBlocked, CCalculationAlgorithmContextBase* calcAlgContext); |
| 367 |
|
| 368 |
bool addSignatureIndividualNodeBlockerCandidate(CIndividualProcessNode*& indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 369 |
|
| 370 |
CIndividualProcessNode* searchSignatureIndividualNodeBlocker(CIndividualProcessNode*& blockingNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 371 |
|
| 372 |
|
| 373 |
bool writeClashDescriptorsToCache(CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 374 |
bool writeClashDescriptorsToCache(CTrackedClashedDescriptor*& trackedClashedDes, CTrackedClashedDescriptor* additionalTrackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 375 |
bool writeClashDescriptorsToCache(CTrackedClashedDescriptor*& trackedClashedDes, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 376 |
bool writeUnsatisfiableClashedDescriptors(CTrackedClashedDescriptor* trackedClashedDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 377 |
CTrackedClashedDescriptor* getSortedClashedDescriptors(CTrackedClashedDescriptor* trackedClashedDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 378 |
bool isClashedDescriptorSortedBefore(CTrackedClashedDescriptor* trackedClashedDesBefore, CTrackedClashedDescriptor* trackedClashedDesAfter, CCalculationAlgorithmContextBase* calcAlgContext); |
| 379 |
|
| 380 |
|
| 381 |
bool addIndiNodeSignatureOfUnsatisfiableClashedDescriptors(CTrackedClashedDescriptor* trackedClashedDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 382 |
|
| 383 |
QString generateDebugTrackedClashedDescriptorSummaryString(CTrackedClashedDescriptor* trackedClashDescriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 384 |
QString generateDebugTrackedClashedDescriptorString(CTrackedClashedDescriptor* trackedClashDescriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 385 |
QString generateDebugTrackingLineString(CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 386 |
|
| 387 |
|
| 388 |
QString writeDebugTrackingLineStringToFile(const QString& debugDataString, const QString& fileNameString, CTrackedClashedDependencyLine* trackingLine, CCalculationAlgorithmContextBase* calcAlgContext); |
| 389 |
|
| 390 |
|
| 391 |
QString generateDebugMergingQueueString(CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 392 |
|
| 393 |
|
| 394 |
bool writeSatisfiableCachedIndividualNodesOfUnsatisfiableBranch(CCalculationAlgorithmContextBase* calcAlgContext); |
| 395 |
bool testAllSuccessorsProcessedAndWriteSatisfiableCache(CIndividualProcessNode* indiNode, CPROCESSINGSET<CIndividualProcessNode*>* processedNodeSet, CSatisfiableExpanderCacheHandler* satExpHandler, CCalculationAlgorithmContextBase* calcAlgContext); |
| 396 |
|
| 397 |
bool cacheSatisfiableIndividualNodes(CCalculationAlgorithmContextBase* calcAlgContext); |
| 398 |
bool isSatisfiableCachedProcessingBlocked(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 399 |
bool isSatisfiableCachedCompatible(CIndividualProcessNode*& individualNode, CExpanderBranchedLinker* satBranchLinker, CIndividualProcessNode* ancestorIndiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 400 |
bool isSatisfiableCachedAutomatConceptCompatible(CIndividualProcessNode*& individualNode, CConcept* concept, bool negated, CIndividualProcessNode* ancestorIndiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 401 |
bool detectIndividualNodeSatisfiableExpandedCached(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 402 |
void expandCachedConcepts(CIndividualProcessNode*& individualNode, CSignatureSatisfiableExpanderCacheEntry* entry, CCalculationAlgorithmContextBase* calcAlgContext); |
| 403 |
void propagateIndirectSuccessorSatisfiableCached(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 404 |
void reactivateIndirectSatisfiableCachedSuccessors(CIndividualProcessNode*& indi, bool recursive, CCalculationAlgorithmContextBase* calcAlgContext); |
| 405 |
void addSatisfiableCachedAbsorbedDisjunctionConcept(CConceptDescriptor *conceptDescriptor, CIndividualProcessNode*& processIndi, CProcessingRestrictionSpecification* procRest, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 406 |
void addSatisfiableCachedAbsorbedGeneratingConcept(CConceptDescriptor *conceptDescriptor, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 407 |
|
| 408 |
|
| 409 |
|
| 410 |
|
| 411 |
bool analyseBranchingStatistics(CCalculationAlgorithmContextBase* calcAlgContext); |
| 412 |
|
| 413 |
|
| 414 |
|
| 415 |
|
| 416 |
bool isSaturationCachedProcessingBlocked(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 417 |
bool detectIndividualNodeSaturationCached(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 418 |
void reactivateIndirectSaturationCachedSuccessors(CIndividualProcessNode*& indi, bool recursive, CCalculationAlgorithmContextBase* calcAlgContext); |
| 419 |
|
| 420 |
|
| 421 |
|
| 422 |
|
| 423 |
|
| 424 |
void markRelevanceForTrackedClashedDescriptors(CTrackedClashedDescriptor* descriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 425 |
void markDependencyRelevance(CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 426 |
|
| 427 |
|
| 428 |
void addIndividualNodeForCacheUnsatisfiableRetrieval(CIndividualProcessNode*& indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 429 |
void testIndividualNodeUnsatisfiableCached(CIndividualProcessNode* individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 430 |
|
| 431 |
void commitCacheMessages(CCalculationAlgorithmContextBase* calcAlgContext); |
| 432 |
|
| 433 |
|
| 434 |
|
| 435 |
|
| 436 |
|
| 437 |
bool hasCommonVariableBindings(CIndividualProcessNode*& processIndi, CRepresentativeVariableBindingPathMap* leftRepVarBindMap, CRepresentativeVariableBindingPathMap* rightRepVarBindMap, CCalculationAlgorithmContextBase* calcAlgContext); |
| 438 |
|
| 439 |
bool areRepresentativesJoinable(CIndividualProcessNode*& processIndi, CRepresentativeVariableBindingPathSetData* leftRepData, CRepresentativeVariableBindingPathSetData* rightRepData, CSortedLinker<CVariable*>* varLinker, CCalculationAlgorithmContextBase* calcAlgContext); |
| 440 |
|
| 441 |
void applyREPRESENTATIVEGROUNDINGRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 442 |
|
| 443 |
void applyREPRESENTATIVEJOINRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 444 |
void applyREPRESENTATIVEBINDVARIABLERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 445 |
|
| 446 |
void applyREPRESENTATIVEIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 447 |
|
| 448 |
void propagateRepresentativeToSuccessor(CIndividualProcessNode* processIndi, CIndividualProcessNode*& succIndi, CSortedNegLinker<CConcept*>* conceptOpLinker, bool negate, CConceptDescriptor* conDes, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 449 |
void applyREPRESENTATIVEALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 450 |
|
| 451 |
void applyREPRESENTATIVEANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 452 |
bool requiresRepresentativePropagation(CIndividualProcessNode*& processIndi, CRepresentativePropagationDescriptor* repPropDes, CRepresentativePropagationSet* testRepPropSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 453 |
void propagateRepresentative(CIndividualProcessNode*& processIndi, CRepresentativePropagationDescriptor* repPropDes, CRepresentativePropagationSet* repPropSet, CDependencyTrackPoint* nextDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 454 |
void updateRepresentativePropagationSet(CIndividualProcessNode*& processIndi, CRepresentativePropagationSet* repPropSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 455 |
|
| 456 |
void reapplyConceptUpdatedRepresentative(CIndividualProcessNode*& processIndi, CConceptDescriptor* bindingConDes, CDependencyTrackPoint* bindingDepTrackPoint, CReapplyConceptLabelSet* conSet, CCondensedReapplyQueue* reapplyQueue, CCalculationAlgorithmContextBase* calcAlgContext); |
| 457 |
void reapplyConceptUpdatedRepresentative(CIndividualProcessNode*& processIndi, CConceptDescriptor* bindingConDes, CDependencyTrackPoint* bindingDepTrackPoint, cint64 bindingCount, CReapplyConceptLabelSet* conSet, CCondensedReapplyQueue* reapplyQueue, CCalculationAlgorithmContextBase* calcAlgContext); |
| 458 |
|
| 459 |
CRepresentativeVariableBindingPathSetJoiningKeyMap* getRepresentativeJoiningKeyData(CRepresentativeVariableBindingPathSetData* repVarBindPathSetData, CConcept* joinConcept, CCalculationAlgorithmContextBase* calcAlgContext); |
| 460 |
|
| 461 |
void createCommonJoiningKeyMap(CRepresentativeJoiningCommonKeyMap* repJoinCommonKeyMap, CRepresentativeVariableBindingPathSetJoiningKeyMap* firstJoiningKeyMap, CRepresentativeVariableBindingPathSetData* firstRepData, |
| 462 |
CRepresentativeVariableBindingPathSetJoiningKeyMap* secJoiningKeyMap, CRepresentativeVariableBindingPathSetData* secRepData, bool firstLeft, CCalculationAlgorithmContextBase* calcAlgContext); |
| 463 |
|
| 464 |
void createCommonJoiningAll(CRepresentativeJoiningCommonKeyMap* repJoinCommonKeyMap, CRepresentativeJoiningAllDataExtension* joinAllExtData, CRepresentativeVariableBindingPathSetData* leftRepData, CRepresentativeVariableBindingPathSetData* rightRepData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 465 |
|
| 466 |
|
| 467 |
|
| 468 |
|
| 469 |
|
| 470 |
|
| 471 |
|
| 472 |
|
| 473 |
|
| 474 |
void applyVARIABLEBINDINGANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 475 |
void applyVARBINDPROPAGATEALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 476 |
void applyVARBINDVARIABLERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 477 |
void applyVARBINDPROPAGATEJOINRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 478 |
|
| 479 |
bool triggerVariableBindingPathJoining(CIndividualProcessNode* processIndi, CVariableBindingPathDescriptor* varBindPathDes, CVariableBindingDescriptor* varBindDes, bool leftTriggered, CVariableBindingTriggerHash* varBindTriggerHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 480 |
|
| 481 |
bool propagateVariableBindingsJoins(CIndividualProcessNode* processIndi, CConceptDescriptor* joiningConDes, CConcept* joinConcept, CVariableBindingPathDescriptor* varBindPathDes, bool leftTriggerPath, |
| 482 |
CVariableBindingPathJoiningHash* varBindPathJoinHash, CConceptVariableBindingPathSetHash* varBindingPathSetHash, CConceptDescriptor*& joinConDes, CVariableBindingPathSet*& varBindingPathSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 483 |
|
| 484 |
CVariableBindingDescriptor* createVariableBindingPathKey(CIndividualProcessNode* processIndi, CSortedLinker<CVariable*>* varLinker, CVariableBindingDescriptor* varBindDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 485 |
CVariableBindingPath* getJoinedVariableBindingPath(CVariableBindingPath* leftVarBindPath, CVariableBindingPath* rightVarBindPath, CCalculationAlgorithmContextBase* calcAlgContext); |
| 486 |
void forceVariableBindingJoinCreated(CIndividualProcessNode* processIndi, CConceptDescriptor* joiningConDes, CConcept* joinConcept, CConceptDescriptor*& joinConDes, CDependencyTrackPoint* mergedDependencyTrackPoint, CVariableBindingPathSet*& varBindingPathSet, CConceptVariableBindingPathSetHash* varBindingPathSetHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 487 |
|
| 488 |
bool propagateInitialVariableBindings(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingSet, CVariableBindingPathSet* prevVarBindingSet, CDependency* otherDependencies, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 489 |
bool propagateFreshVariableBindings(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingSet, CVariableBindingPathSet* prevVarBindingSet, CDependency* otherDependencies, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 490 |
|
| 491 |
void propagateVariableBindingsToSuccessor(CIndividualProcessNode* processIndi, CIndividualProcessNode*& succIndi, CSortedNegLinker<CConcept*>* conceptOpLinker, bool negate, CConceptDescriptor* conDes, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 492 |
bool propagateInitialVariableBindingsToSuccessor(CIndividualProcessNode*& processIndi, CIndividualProcessNode* succIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingSet, CVariableBindingPathSet* prevVarBindingSet, CIndividualLinkEdge* restLink, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 493 |
bool propagateFreshVariableBindingsToSuccessor(CIndividualProcessNode*& processIndi, CIndividualProcessNode* succIndi, CConceptDescriptor* conDes, CVariableBindingPathSet* newVarBindingSet, CVariableBindingPathSet* prevVarBindingSet, CIndividualLinkEdge* restLink, CConceptVariableBindingPathSetHash* conVarBindingSetHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 494 |
|
| 495 |
void applyVARBINDPROPAGATEGROUNDINGRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 496 |
void applyVARBINDPROPAGATEIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 497 |
|
| 498 |
|
| 499 |
void applyVARBINDPREPARERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 500 |
void applyVARBINDFINALIZERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 501 |
|
| 502 |
|
| 503 |
|
| 504 |
|
| 505 |
|
| 506 |
|
| 507 |
|
| 508 |
|
| 509 |
|
| 510 |
|
| 511 |
void applyBINDPROPAGATEGROUNDINGRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 512 |
void applyBINDPROPAGATECYCLERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 513 |
void applyBINDPROPAGATEALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 514 |
void applyBINDPROPAGATEIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 515 |
void applyBINDPROPAGATEANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 516 |
void applyBINDPROPAGATEANDFLAGALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 517 |
void propagatePropagationBindings(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, bool propagateAllFlag, CCalculationAlgorithmContextBase* calcAlgContext); |
| 518 |
void applyBINDVARIABLERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 519 |
|
| 520 |
bool propagateInitialPropagationBindings(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CPropagationBindingSet* newPropBindingSet, CPropagationBindingSet* prevPropBindingSet, CDependency* otherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 521 |
bool propagateFreshPropagationBindings(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CPropagationBindingSet* newPropBindingSet, CPropagationBindingSet* prevPropBindingSet, CDependency* otherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 522 |
|
| 523 |
void propagatePropagationBindingsToSuccessor(CIndividualProcessNode* processIndi, CIndividualProcessNode*& succIndi, CSortedNegLinker<CConcept*>* conceptOpLinker, bool negate, CConceptDescriptor* conDes, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 524 |
bool propagateInitialPropagationBindingsToSuccessor(CIndividualProcessNode*& processIndi, CIndividualProcessNode* succIndi, CConceptDescriptor* conDes, CPropagationBindingSet* newPropBindingSet, CPropagationBindingSet* prevPropBindingSet, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 525 |
bool propagateFreshPropagationBindingsToSuccessor(CIndividualProcessNode*& processIndi, CIndividualProcessNode* succIndi, CConceptDescriptor* conDes, CPropagationBindingSet* newPropBindingSet, CPropagationBindingSet* prevPropBindingSet, CIndividualLinkEdge* restLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 526 |
|
| 527 |
void applyReapplyQueueConcepts(CIndividualProcessNode*& processIndi, CPropagationBindingReapplyConceptDescriptor* reapplyDesLinker, CCalculationAlgorithmContextBase* calcAlgContext); |
| 528 |
|
| 529 |
|
| 530 |
|
| 531 |
|
| 532 |
|
| 533 |
|
| 534 |
void addRoleAssertion(CIndividualProcessNode*& processIndi, CRoleAssertionLinker* roleAssertionLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 535 |
void addReverseRoleAssertion(CIndividualProcessNode*& processIndi, CReverseRoleAssertionLinker* reverseRoleAssertionLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 536 |
|
| 537 |
void addDataAssertion(CIndividualProcessNode*& processIndi, CDataAssertionLinker* dataAssertionLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 538 |
|
| 539 |
bool checkBackendCachedNominalConnection(CIndividualProcessNode*& processIndi, CRole* role, cint64 nominalId, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 540 |
|
| 541 |
void applyAutomatChooseRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 542 |
void applyBOTTOMRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 543 |
void applyANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 544 |
void applySOMERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 545 |
void applyALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 546 |
void applyORRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 547 |
void applySELFRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 548 |
void applyAutomatANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 549 |
void applyAutomatTransactions(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, CConcept* concept, bool negated, CCalculationAlgorithmContextBase* calcAlgContext); |
| 550 |
void applyFUNCTIONALRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 551 |
void applyATMOSTRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 552 |
void applyATLEASTRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 553 |
void applyNOMINALRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 554 |
void applyVALUERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 555 |
void applyIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 556 |
void applyDATALITERALRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 557 |
void applyDATARESTRICTIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 558 |
void applyDATATYPERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 559 |
void applyNOMINALIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 560 |
void applyDATALITERALIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 561 |
void applyDATATYPEIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 562 |
void applyDATARESTRICTIONIMPLICATIONRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 563 |
|
| 564 |
|
| 565 |
void applyNegAutomatChooseRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 566 |
void applyNegANDRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 567 |
void applyNegSOMERule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 568 |
void applyNegALLRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 569 |
void applyNegORRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 570 |
void applyNegATMOSTRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 571 |
void applyNegATLEASTRule(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 572 |
|
| 573 |
|
| 574 |
bool hasIdenticalConceptOperands(CSortedNegLinker<CConcept*>* opConLinker1, CSortedNegLinker<CConcept*>* opConLinker2); |
| 575 |
|
| 576 |
|
| 577 |
|
| 578 |
|
| 579 |
CREPRESENTATIVEGROUNDINGDependencyNode* createREPRESENTATIVEGROUNDINGDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CVariableBindingPath* selectVarBindPath, CCalculationAlgorithmContextBase* calcAlgContext); |
| 580 |
CREPRESENTATIVEJOINDependencyNode* createREPRESENTATIVEJOINDependency(CDependencyTrackPoint*& joinContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* otherDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 581 |
CREPRESENTATIVEBINDVARIABLEDependencyNode* createREPRESENTATIVEBINDVARIABLEDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 582 |
CREPRESENTATIVEIMPLICATIONDependencyNode* createREPRESENTATIVEIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 583 |
CREPRESENTATIVEALLDependencyNode* createREPRESENTATIVEALLDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 584 |
CREPRESENTATIVEANDDependencyNode* createREPRESENTATIVEANDDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 585 |
CRESOLVEREPRESENTATIVEDependencyNode* createRESOLVEREPRESENTATIVEDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CRepresentativeVariableBindingPathMap* resolveVarBindPathMap, CRepresentativePropagationMap* resolveRepPropMap, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* additionalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 586 |
|
| 587 |
|
| 588 |
CVARBINDPROPAGATEJOINDependencyNode* createVARBINDPROPAGATEJOINDependency(CDependencyTrackPoint*& continueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* otherDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 589 |
CVARBINDPROPAGATEALLDependencyNode* createVARBINDPROPAGATEALLDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 590 |
CVARBINDPROPAGATEANDDependencyNode* createVARBINDPROPAGATEANDDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 591 |
CPROPAGATEVARIABLEBINDINGDependencyNode* createPROPAGATEVARIABLEBINDINGDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 592 |
CPROPAGATEVARIABLEBINDINGSSUCCESSORDependencyNode* createPROPAGATEVARIABLEBINDINGSSUCCESSORDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 593 |
CVARBINDVARIABLEDependencyNode* createVARBINDVARIABLEDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 594 |
CVARBINDPROPAGATEGROUNDINGDependencyNode* createVARBINDPROPAGATEGROUNDINGDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 595 |
CPROPAGATEVARIABLECONNECTIONDependencyNode* createPROPAGATEVARIABLECONNECTIONDependency(CIndividualProcessNode* processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 596 |
CVARBINDPROPAGATEIMPLICATIONDependencyNode* createVARBINDPROPAGATEIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 597 |
|
| 598 |
CBINDPROPAGATEGROUNDINGDependencyNode* createBINDPROPAGATEGROUNDINGDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 599 |
CPROPAGATECONNECTIONAWAYDependencyNode* createPROPAGATECONNECTIONAWAYDependency(CIndividualProcessNode* processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 600 |
CPROPAGATECONNECTIONDependencyNode* createPROPAGATECONNECTIONDependency(CIndividualProcessNode* processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 601 |
CBINDPROPAGATECYCLEDependencyNode* createBINDPROPAGATECYCLEDependency(CDependencyTrackPoint*& continueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* triggDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 602 |
CBINDPROPAGATEALLDependencyNode* createBINDPROPAGATEALLDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 603 |
CPROPAGATEBINDINGSSUCCESSORDependencyNode* createPROPAGATEBINDINGSSUCCESSORDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 604 |
CBINDPROPAGATEIMPLICATIONDependencyNode* createBINDPROPAGATEIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 605 |
CBINDPROPAGATEANDDependencyNode* createBINDPROPAGATEANDDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 606 |
CPROPAGATEBINDINGDependencyNode* createPROPAGATEBINDINGDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 607 |
CBINDVARIABLEDependencyNode* createBINDVARIABLEDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 608 |
CANDDependencyNode* createANDDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 609 |
CSOMEDependencyNode* createSOMEDependency(CDependencyTrackPoint*& someContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 610 |
CSELFDependencyNode* createSELFDependency(CDependencyTrackPoint*& selfContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 611 |
CVALUEDependencyNode* createVALUEDependency(CDependencyTrackPoint*& valueContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 612 |
CROLEASSERTIONDependencyNode* createROLEASSERTIONDependency(CDependencyTrackPoint*& roleAssContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CRole* baseAssertionRole, CIndividual* baseAssertionIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 613 |
CDATAASSERTIONDependencyNode* createDATAASSERTIONDependency(CDependencyTrackPoint*& roleAssContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 614 |
CALLDependencyNode* createALLDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 615 |
CATLEASTDependencyNode* createATLEASTDependency(CDependencyTrackPoint*& atleastContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 616 |
CAUTOMATTRANSACTIONDependencyNode* createAUTOMATTRANSACTIONDependency(CDependencyTrackPoint*& allContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* linkDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 617 |
CAUTOMATCHOOSEDependencyNode* createAUTOMATCHOOSEDependency(CDependencyTrackPoint*& andContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 618 |
CDISTINCTDependencyNode* createDISTINCTDependency(CDependencyTrackPoint*& distinctContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 619 |
CNEGVALUEDependencyNode* createNEGVALUEDependency(CDependencyTrackPoint*& negValueContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 620 |
CNOMINALDependencyNode* createNOMINALDependency(CDependencyTrackPoint*& nominalContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 621 |
CFUNCTIONALDependencyNode* createFUNCTIONALDependency(CDependencyTrackPoint*& functionalContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* prevLink1DependencyTrackPoint, CDependencyTrackPoint* prevLink2DependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 622 |
|
| 623 |
CORDependencyNode* createORDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 624 |
CATMOSTDependencyNode* createATMOSTDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 625 |
CMERGEDependencyNode* createMERGEDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 626 |
CREUSEINDIVIDUALDependencyNode* createREUSEINDIVIDUALDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 627 |
CREUSECOMPLETIONGRAPHDependencyNode* createREUSECOMPLETIONGRAPHDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 628 |
CMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode* createMERGEPOSSIBLEINSTANCEINDIVIDUALDependencyNode(CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CIndividualProcessNode* mergingIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 629 |
CREUSECONCEPTSDependencyNode* createREUSECONCEPTSDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 630 |
CQUALIFYDependencyNode* createQUALIFYDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 631 |
|
| 632 |
CMERGEDCONCEPTDependencyNode* createMERGEDCONCEPTDependency(CDependencyTrackPoint*& mergedConceptContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* mergePrevDepTrackPoint, CDependencyTrackPoint* conceptPrevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 633 |
CMERGEDLINKDependencyNode* createMERGEDLINKDependency(CDependencyTrackPoint*& mergedLinkContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* mergePrevDepTrackPoint, CDependencyTrackPoint* linkPrevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 634 |
CMERGEDIndividualDependencyNode* createMERGEDINDIVIDUALDependency(CDependencyTrackPoint*& mergedIndividualContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* mergePrevDepTrackPoint, CDependencyTrackPoint* individualPrevDepTrackPoint, CCalculationAlgorithmContext* calcAlgContext); |
| 635 |
|
| 636 |
CORONLYOPTIONDependencyNode* createORONLYOPTIONDependency(CDependencyTrackPoint*& orContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 637 |
CIMPLICATIONDependencyNode* createIMPLICATIONDependency(CDependencyTrackPoint*& implContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 638 |
CEXPANDEDDependencyNode* createEXPANDEDDependency(CDependencyTrackPoint*& expContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CDependency* prevOtherDependencies, CCalculationAlgorithmContextBase* calcAlgContext); |
| 639 |
CCONNECTIONDependencyNode* createCONNECTIONDependency(CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 640 |
|
| 641 |
CSAMEINDIVIDUALSMERGEDependencyNode* createSAMEINDIVIDUALMERGEDependency(CDependencyTrackPoint*& expContinueDepTrackPoint, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* prevOtherDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 642 |
|
| 643 |
CNonDeterministicDependencyTrackPoint* createNonDeterministicDependencyTrackPointBranch(CNonDeterministicDependencyNode* dependencyNode, bool singleBranch, CCalculationAlgorithmContextBase* calcAlgContext); |
| 644 |
|
| 645 |
CREUSEBACKENDEXPANSIONMODESDependencyNode* createREUSEBACKENDEXPANSIONMODESDependency(CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 646 |
CREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDependencyNode* createREUSEBACKENDFIXEDINDIVIDUALEXPANSIONDependency(CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 647 |
CREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDependencyNode* createREUSEBACKENDPRIORITIZEDINDIVIDUALEXPANSIONDependency(CIndividualProcessNode*& processIndi, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 648 |
CREUSEBACKENDVALUEDependencyNode* createREUSEBACKENDVALUEDependency(CDependencyTrackPoint*& valueDepTrackPoint, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CDependencyTrackPoint* nominalDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 649 |
|
| 650 |
|
| 651 |
bool isRestrictedTopObjectPropertyPropagation(CIndividualProcessNode*& processIndi, CIndividualProcessNode*& destIndi, CConcept* concept, bool negated, CCalculationAlgorithmContextBase* calcAlgContext); |
| 652 |
|
| 653 |
|
| 654 |
bool isConceptAdditionAtomaric(CConcept* addingConcept, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 655 |
|
| 656 |
CClashedDependencyDescriptor* createIndividualMergeCausingDescriptors(CClashedDependencyDescriptor* prevClashes, CIndividualProcessNode*& processIndi, CIndividualLinkEdge* link, CSortedNegLinker<CConcept*>* conceptAddLinker, CCalculationAlgorithmContextBase* calcAlgContext); |
| 657 |
|
| 658 |
|
| 659 |
CClashedDependencyDescriptor* createClashedIndividualNodeDescriptor(CClashedDependencyDescriptor* prevClashes, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 660 |
CClashedDependencyDescriptor* createClashedConceptDescriptor(CClashedDependencyDescriptor* prevClashes, CIndividualProcessNode*& processIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 661 |
CClashedDependencyDescriptor* createClashedIndividualLinkDescriptor(CClashedDependencyDescriptor* prevClashes, CIndividualLinkEdge* link, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 662 |
CClashedDependencyDescriptor* createClashedIndividualDistinctDescriptor(CClashedDependencyDescriptor* prevClashes, CDistinctEdge* distinct, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 663 |
CClashedDependencyDescriptor* createClashedNegationDisjointDescriptor(CClashedDependencyDescriptor* prevClashes, CNegationDisjointEdge* disjointNegLink, CDependencyTrackPoint* prevDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 664 |
|
| 665 |
bool isNominalIndividualNodeAvailable(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 666 |
|
| 667 |
CIndividualProcessNode* getCorrectedNominalIndividualNode(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 668 |
CIndividualProcessNode* getCorrectedMergedIntoIndividualNode(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 669 |
CIndividualProcessNode* getForcedInitializedNominalIndividualNode(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 670 |
|
| 671 |
|
| 672 |
void initializeMergingIndividualNodes(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, CRoleSuccessorLinkIterator* roleSuccIt, CIndividualLinkEdge* usingLastLink, CSortedNegLinker<CConcept*>* conceptOpLinkerIt, CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 673 |
bool qualifyMergingIndividualNodes(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 674 |
bool mergeMergingIndividualNodes(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, cint64 linkCount, cint64 cardinality, CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 675 |
bool mergeMergingIndividualNodesPairwise(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, cint64 linkCount, cint64 cardinality, CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 676 |
CSatisfiableCalculationTask* createMergeBranchingTask(CIndividualProcessNode*& processIndiNode, CConceptProcessDescriptor*& conProDes, CIndividualProcessNode*& distinctIndiNode, CIndividualProcessNode*& mergingIndiNode, CNonDeterministicDependencyNode* mergeDependencyNode, CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 677 |
CSatisfiableCalculationTask* createDistinctBranchingTask(CIndividualProcessNode*& processIndiNode, CConceptProcessDescriptor*& conProDes, CIndividualProcessNode*& distinctIndiNode, bool createAsNominal, CNonDeterministicDependencyNode* mergeDependencyNode, CBranchingMergingProcessingRestrictionSpecification* branchingMergingProcRest, CCalculationAlgorithmContextBase* calcAlgContext); |
| 678 |
|
| 679 |
|
| 680 |
|
| 681 |
bool getAdditionalDisjunctCheckingConcept(CConcept* opConcept, bool opConNegation, CConcept** checkingConcept, bool* checkingNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 682 |
|
| 683 |
|
| 684 |
bool hasSaturatedClashedFlagForConcept(CConcept* concept, bool negation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 685 |
bool initializeORProcessing(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CBranchingORProcessingRestrictionSpecification** plannedBranchingProcessRestriction, CCalculationAlgorithmContextBase* calcAlgContext); |
| 686 |
bool planORProcessing(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CBranchingORProcessingRestrictionSpecification** plannedBranchingProcessRestriction, CCalculationAlgorithmContextBase* calcAlgContext); |
| 687 |
void executeORBranching(CIndividualProcessNode*& processIndi, CConceptProcessDescriptor*& conProDes, bool negate, CBranchingORProcessingRestrictionSpecification* plannedBranchingProcessRestriction, CCalculationAlgorithmContextBase* calcAlgContext); |
| 688 |
|
| 689 |
CSatisfiableCalculationTask* createDependendBranchingTaskList(cint64 newTaskCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 690 |
void prepareBranchedTaskProcessing(CIndividualProcessNode*& individual, CSatisfiableCalculationTask* newTask, CCalculationAlgorithmContextBase* calcAlgContext); |
| 691 |
|
| 692 |
CConceptRoleBranchingTrigger* searchNextConceptRoleBranchTrigger(CIndividualProcessNode*& processIndi, CConceptRoleBranchingTrigger* triggers, CCalculationAlgorithmContextBase* calcAlgContext); |
| 693 |
void installConceptRoleBranchTrigger(CIndividualProcessNode*& processIndi, CConceptDescriptor* conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CProcessingRestrictionSpecification* procRest, CConceptRoleBranchingTrigger* trigger, CCalculationAlgorithmContextBase* calcAlgContext); |
| 694 |
|
| 695 |
CConceptDescriptor* addConceptToIndividualReturnConceptDescriptor(CConcept* addingConcept, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, CCalculationAlgorithmContextBase* calcAlgContext); |
| 696 |
void addConceptToIndividualSkipANDProcessing(CConcept* addingConcept, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, bool markModification, CCalculationAlgorithmContextBase* calcAlgContext); |
| 697 |
void addConceptToIndividual(CConcept* addingConcept, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, CCalculationAlgorithmContextBase* calcAlgContext); |
| 698 |
void addConceptsToIndividual(CSortedNegLinker<CConcept*>* conceptAddLinker, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, cint64* conceptCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 699 |
void addConceptsToIndividual(CXNegLinker<CConcept*>* conceptAddLinker, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, cint64* conceptCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 700 |
void addConceptsToIndividual(CConceptAssertionLinker* conceptAddLinker, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, cint64* conceptCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 701 |
void addConceptsToIndividual(CXSortedNegLinker<CConcept*>* conceptAddLinker, bool negate, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, bool allowPreprocessing, bool allowInitalization, cint64* conceptCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 702 |
|
| 703 |
bool insertConceptsToIndividualConceptSet(CConceptDescriptor* conceptDescriptor, CDependencyTrackPoint* dependencyTrackPoint, CIndividualProcessNode*& processIndi, CReapplyConceptLabelSet* conLabelSet, CCondensedReapplyQueueIterator* reapplyIt, bool allowInitalization, CCalculationAlgorithmContextBase* calcAlgContext); |
| 704 |
bool addBlockingCoreConcept(CConceptDescriptor* conceptDescriptor, CIndividualProcessNode*& processIndi, CReapplyConceptLabelSet* conLabelSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 705 |
|
| 706 |
bool isConceptUnsatisfiabilitySaturated(CConcept* concept, bool negation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 707 |
|
| 708 |
|
| 709 |
bool needsProcessingForConcept(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 710 |
|
| 711 |
void insertConceptProcessDescriptorToProcessingQueue(CConceptProcessDescriptor* conProDes, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 712 |
void insertConceptProcessDescriptorToProcessingQueue(CConceptProcessDescriptor* conProDes, CConceptProcessingQueue*& conceptProcessingQueue, cint64 bindingCount, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 713 |
|
| 714 |
void addConceptPreprocessedToProcessingQueue(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, cint64 bindingCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 715 |
void addConceptToProcessingQueue(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, bool reapplied, CCalculationAlgorithmContextBase* calcAlgContext); |
| 716 |
void addConceptPreprocessedToProcessingQueue(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, bool allowPreprocessing, CCalculationAlgorithmContextBase* calcAlgContext, TableauRuleFunction skipFunction = nullptr); |
| 717 |
void addConceptToProcessingQueue(CConceptProcessDescriptor* reinsertConProDes, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 718 |
void addCopiedConceptToProcessingQueue(CConceptProcessDescriptor* copyConProDes, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 719 |
void addConceptRestrictedToProcessingQueue(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, bool reapplied, CProcessingRestrictionSpecification* procRestriction, CCalculationAlgorithmContextBase* calcAlgContext); |
| 720 |
void addConceptRestrictedToProcessingQueue(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, bool reapplied, CProcessingRestrictionSpecification* procRestriction, double priorityOffset, CCalculationAlgorithmContextBase* calcAlgContext); |
| 721 |
void addConceptRestrictedFixedPriorityToProcessingQueue(CConceptDescriptor *conceptDescriptor, CDependencyTrackPoint* depTrackPoint, CConceptProcessingQueue*& conceptProcessingQueue, CIndividualProcessNode*& processIndi, bool reapplied, CProcessingRestrictionSpecification* procRestriction, double priority, CCalculationAlgorithmContextBase* calcAlgContext); |
| 722 |
bool addIndividualToProcessingQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 723 |
bool addIndividualToProcessingQueueBasedOnProcessingConcepts(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 724 |
bool addIndividualToBlockingUpdateReviewProcessingQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 725 |
bool addIndividualToBackendSynchronisationRetestQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 726 |
|
| 727 |
bool addIndividualToBackendDirectInfluenceExpansionQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 728 |
bool addIndividualToBackendIndirectCompatibilityExpansionQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 729 |
bool addIndividualToBackendReuseExpansionQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 730 |
bool addIndividualToBackendNeighbourExpansionQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 731 |
|
| 732 |
bool registerProcessedIndividualForBackendConceptSetLabel(CIndividualProcessNode* individual, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, CBackendRepresentativeMemoryCacheIndividualAssociationData* indiAssData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 733 |
|
| 734 |
|
| 735 |
|
| 736 |
|
| 737 |
bool addIndividualToIncrementalCompatibilityCheckingQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 738 |
bool addIndividualToIncrementalExpansionQueue(CIndividualProcessNode* individual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 739 |
|
| 740 |
|
| 741 |
|
| 742 |
bool isConceptInReapplyQueue(CConceptDescriptor* conceptDescriptor, CConcept* concept, bool negation, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 743 |
bool isConceptInReapplyQueue(CConceptDescriptor* conceptDescriptor, CRole* role, CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 744 |
|
| 745 |
void addConceptToReapplyQueue(CConceptDescriptor *conceptDescriptor, CRole* role, CIndividualProcessNode*& processIndi, CProcessingRestrictionSpecification* procRest, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 746 |
void addConceptToReapplyQueue(CConceptDescriptor *conceptDescriptor, CConcept* concept, bool negation, CIndividualProcessNode*& processIndi, CProcessingRestrictionSpecification* procRest, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 747 |
|
| 748 |
void addConceptToReapplyQueue(CConceptDescriptor *conceptDescriptor, CRole* role, CIndividualProcessNode*& processIndi, bool isStaticDes, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 749 |
void addConceptToReapplyQueue(CConceptDescriptor *conceptDescriptor, CConcept* concept, bool negation, CIndividualProcessNode*& processIndi, bool isStaticDes, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 750 |
void addConceptToReapplyQueue(CConceptDescriptor *conceptDescriptor, CIndividualProcessNode*& processIndi, CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 751 |
|
| 752 |
void applyReapplyQueueConcepts(CIndividualProcessNode*& processIndi, CConcept* concept, bool negation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 753 |
void applyReapplyQueueConcepts(CIndividualProcessNode*& processIndi, CRole* role, CCalculationAlgorithmContextBase* calcAlgContext); |
| 754 |
void applyReapplyQueueConceptsRestricted(CIndividualProcessNode*& processIndi, CReapplyQueueIterator* reapplyQueueIt, CIndividualLinkEdge* restrictedLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 755 |
void applyReapplyQueueConcepts(CIndividualProcessNode*& processIndi, CCondensedReapplyQueueIterator* reapplyQueueIt, CCalculationAlgorithmContextBase* calcAlgContext); |
| 756 |
|
| 757 |
void applyExtendedReapplyConceptDescriptor(CIndividualProcessNode*& processIndi, CConcept* concept, bool negation, CCondensedReapplyConceptDescriptor* reapplyConceptDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 758 |
|
| 759 |
|
| 760 |
bool hasRoleSuccessorConcept(CIndividualProcessNode*& processIndi, CRole* role, CConcept* concept, bool conceptNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 761 |
bool hasRoleSuccessorConcepts(CIndividualProcessNode*& processIndi, CRole* role, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 762 |
CIndividualProcessNode* getRoleSuccessorWithConcepts(CIndividualProcessNode*& processIndi, CRole* role, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, CCalculationAlgorithmContextBase* calcAlgContext); |
| 763 |
bool hasDistinctRoleSuccessorConcepts(CIndividualProcessNode*& processIndi, CRole* role, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, cint64 distinctCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 764 |
|
| 765 |
bool hasAncestorIndividualNode(CIndividualProcessNode*& processIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 766 |
bool containsIndividualNodeConcept(CIndividualProcessNode*& testIndi, CConcept* conTest, bool* containsNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 767 |
bool containsIndividualNodeConcept(CReapplyConceptLabelSet* conLabelSet, CConcept* conTest, bool* containsNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 768 |
bool containsIndividualNodeConcepts(CIndividualProcessNode*& testIndi, CSortedNegLinker<CConcept*>* conTestLinkerIt, bool negated, CCalculationAlgorithmContextBase* calcAlgContext); |
| 769 |
bool containsIndividualNodeConcepts(CReapplyConceptLabelSet* conLabelSet, CSortedNegLinker<CConcept*>* conTestLinkerIt, bool negated, CCalculationAlgorithmContextBase* calcAlgContext); |
| 770 |
bool containsIndividualNodeConcepts(CReapplyConceptLabelSet* conLabelSet, CSortedNegLinker<CConcept*>* conTestLinkerIt, bool* containsNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 771 |
bool containsIndividualNodeConcepts(CIndividualProcessNode*& testIndi, CSortedNegLinker<CConcept*>* conTestLinkerIt, bool* containsNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 772 |
bool containsIndividualNodeConcepts(CIndividualProcessNode*& testIndi, CSortedNegLinker<CConcept*>* conTestLinkerIt, CCalculationAlgorithmContextBase* calcAlgContext); |
| 773 |
|
| 774 |
|
| 775 |
|
| 776 |
bool isLabelConceptSubSetIgnoreNominals(CReapplyConceptLabelSet* subConceptSet, CReapplyConceptLabelSet* superConceptSet, bool* clashFlag, CCalculationAlgorithmContextBase* calcAlgContext); |
| 777 |
|
| 778 |
bool isLabelConceptSubSet(CReapplyConceptLabelSet* subConceptSet, CReapplyConceptLabelSet* superConceptSet, CConceptDescriptor** firstNotEntailedConDes, bool* equalSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 779 |
bool isLabelConceptEqualSet(CReapplyConceptLabelSet* conceptSet1, CReapplyConceptLabelSet* conceptSet2, CCalculationAlgorithmContextBase* calcAlgContext); |
| 780 |
bool isPairwiseLabelConceptEqualSet(CReapplyConceptLabelSet* conceptSet1, CReapplyConceptLabelSet* conceptSet1Pair, CReapplyConceptLabelSet* conceptSet2, CReapplyConceptLabelSet* conceptSet2Pair, CCalculationAlgorithmContextBase* calcAlgContext); |
| 781 |
bool isLabelConceptClashSet(CIndividualProcessNode* indi1, CIndividualProcessNode* indi2, CClashedDependencyDescriptor*& clashDescriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 782 |
bool isLabelConceptEqualSetConsiderNominalsForClashOnly(CReapplyConceptLabelSet* conceptSet1, CReapplyConceptLabelSet* conceptSet2, bool* clashFlag, CCalculationAlgorithmContextBase* calcAlgContext); |
| 783 |
bool isLabelConceptClashSet(CReapplyConceptLabelSet* subConceptSet, CReapplyConceptLabelSet* superConceptSet, bool* subSetFlag, bool ignoreNominalsForSubsetChecking, CCalculationAlgorithmContextBase* calcAlgContext); |
| 784 |
|
| 785 |
|
| 786 |
bool hasOptimizedBlockingB2AutomateTransitionOperands(CConcept* opConcept, CRole* role, CReapplyConceptLabelSet* vConSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 787 |
bool isLabelConceptOptimizedBlocking(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 788 |
bool isLabelConceptSubSetBlocking(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 789 |
bool isLabelConceptEqualBlocking(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 790 |
bool isLabelConceptEqualPairwiseBlocking(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 791 |
|
| 792 |
bool isIndividualNodeBlocking(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 793 |
|
| 794 |
|
| 795 |
bool isNominalVariablePropagationBindingSubSet(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 796 |
|
| 797 |
|
| 798 |
bool areVariablePropagationBindingsCompatible(CVariableBindingPath* varBindPath1, CVariableBindingPath* varBindPath2, CCalculationAlgorithmContextBase* calcAlgContext); |
| 799 |
QSet< QSet<CConcept*> > getIndividualNodeAssociatedConceptsSetFromVariablePropagationBindings(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 800 |
QSet< QSet<CConcept*> > getIndividualNodeAssociatedConceptsSetFromVariablePropagationBindingsCached(CIndividualProcessNode*& individualNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 801 |
|
| 802 |
bool collectIndividualNodeVariablePropagationBindings(CIndividualProcessNode*& individualNode, QHash<cint64, CVariableBindingPath*>& collecingPropagationVariableBindingsHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 803 |
|
| 804 |
QSet< QList< QSet<CConcept*> > > getIndividualNodesListAssociatedConceptsSetFromVariablePropagationBindings(CIndividualProcessNode*& individualNode, CIndividualProcessNode*& ancestorIndividualNode, const QList<cint64>& dependentNominalIdList, CCalculationAlgorithmContextBase* calcAlgContext); |
| 805 |
QSet<CConcept*> getConceptsForCompatibleVariablePropagationBindings(CIndividualProcessNode*& individualNode, CVariableBindingPath* varBindPath, CCalculationAlgorithmContextBase* calcAlgContext); |
| 806 |
bool isAnonymousVariablePropagationBindingSingleIndividualAnalogousPath(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 807 |
bool isAnonymousVariablePropagationBindingAnalogousPath(CIndividualProcessNode*& testIndi, CIndividualProcessNode*& blockingIndi, CIndividualNodeBlockingTestData* blockData, bool testContinueBlocking, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 808 |
QString generateDebugIndividualNodesListAssociatedConceptsSetString(CIndividualProcessNode*& individualNode, CIndividualProcessNode*& ancestorIndividualNode, const QList<cint64>& dependentNominalIdList, const QSet< QList< QSet<CConcept*> > >& testIndiAllVariableMappingsAssociatedConceptsOverNodesListSet, const QString& nodeNaming, CCalculationAlgorithmContextBase* calcAlgContext); |
| 809 |
QString generateDebugIndividualNodeAssociatedConceptsString(cint64 indiNodeId, const QSet<CConcept*>& associatedConcepts, CCalculationAlgorithmContextBase* calcAlgContext); |
| 810 |
QString generateDebugIndividualNodeAssociatedConceptsSetString(CIndividualProcessNode*& individualNode, const QSet< QSet<CConcept*> >& allVariableMappingsAssociatedConceptsSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 811 |
cint64 getBindingsCompatibleConceptSetsHashValue(const QSet< QSet<CConcept*> >& associatedConceptSets, CCalculationAlgorithmContextBase* calcAlgContext); |
| 812 |
|
| 813 |
|
| 814 |
|
| 815 |
CBlockingIndividualNodeCandidateIterator getBlockingIndividualNodeCandidateIterator(CIndividualProcessNode* blockingTestIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 816 |
void addIndividualNodeCandidateForConcept(CIndividualProcessNode*& indi, CConceptDescriptor* conDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 817 |
void addIndividualNodeCandidateForConcept(CIndividualProcessNode*& indi, CSortedNegLinker<CConcept*>* concepts, bool negated, CCalculationAlgorithmContextBase* calcAlgContext); |
| 818 |
|
| 819 |
void propagateIndividualNodeModified(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 820 |
void setIndividualNodeConceptLabelSetModified(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 821 |
void setIndividualNodeAncestorConnectionModified(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 822 |
|
| 823 |
bool isIndividualNodeConceptLabelSetModified(CIndividualProcessNode*& indi, cint64 modTag, CCalculationAlgorithmContextBase* calcAlgContext); |
| 824 |
|
| 825 |
void propagateProcessingRestrictionToAncestor(CIndividualProcessNode*& indi, cint64 addRestrictionFlags, bool recursive, cint64 whileNotContainsFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 826 |
void propagateAddingProcessingRestrictionToAncestor(CIndividualProcessNode*& indi, cint64 addRestrictionFlags, bool recursive, cint64 whileNotContainsFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 827 |
|
| 828 |
void propagateAddingBlockedProcessingRestrictionToSuccessors(CIndividualProcessNode*& indi, cint64 addRestrictionFlags, bool recursive, cint64 whileNotContainsFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 829 |
|
| 830 |
void propagateProcessingRestrictionToSuccessors(CIndividualProcessNode*& indi, cint64 addRestrictionFlags, bool recursive, cint64 whileNotContainsFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 831 |
void propagateAddingProcessingRestrictionToSuccessors(CIndividualProcessNode*& indi, cint64 addRestrictionFlags, bool recursive, cint64 whileNotContainsFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 832 |
void propagateClearingProcessingRestrictionToSuccessors(CIndividualProcessNode*& indi, cint64 clearRestrictionFlags, bool recursive, cint64 whileContainsFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 833 |
|
| 834 |
void propagateIndirectSuccessorBlocking(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 835 |
void pruneSuccessors(CIndividualProcessNode*& indi, CIndividualProcessNode* ancestorIndi, bool removeNominalLinks, CCalculationAlgorithmContextBase* calcAlgContext); |
| 836 |
|
| 837 |
bool detectIndividualNodeBlockedStatus(CIndividualProcessNode*& testIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 838 |
CIndividualProcessNode* getBlockingIndividualNode(CIndividualProcessNode* blockingTestIndi, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 839 |
CIndividualProcessNode* getAncestorBlockingIndividualNode(CIndividualProcessNode* blockingTestIndi, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 840 |
CIndividualProcessNode* getAnywhereBlockingIndividualNode(CIndividualProcessNode* blockingTestIndi, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 841 |
CIndividualProcessNode* getAnywhereBlockingIndividualNodeCanidateHashed(CIndividualProcessNode* blockingTestIndi, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 842 |
CIndividualProcessNode* getAnywhereBlockingIndividualNodeLinkedCanidateHashed(CIndividualProcessNode* blockingTestIndi, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 843 |
void clearBlockingCache(CCalculationAlgorithmContextBase* calcAlgContext); |
| 844 |
|
| 845 |
|
| 846 |
bool testAlternativeBlocked(CIndividualProcessNode*& testIndi, CBlockingAlternativeData* blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 847 |
|
| 848 |
bool isIndividualNodeProcessingBlocked(CIndividualProcessNode* blockingTestIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 849 |
bool isIndividualNodeExpansionBlocked(CIndividualProcessNode* blockingTestIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 850 |
|
| 851 |
bool needsIndividualNodeExpansionBlockingTest(CConceptProcessDescriptor* conProDes, CIndividualProcessNode* blockingTestIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 852 |
|
| 853 |
|
| 854 |
CIndividualProcessNode* getDelayProcessingBlockingNominalNode(CIndividualProcessNode* testIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 855 |
|
| 856 |
bool tryDelayNominalProcessing(CConceptProcessDescriptor* conProDes, CIndividualProcessNode* testIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 857 |
bool canDelayNominalProcessing(CConceptProcessDescriptor* conProDes, CIndividualProcessNode* testIndi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 858 |
|
| 859 |
|
| 860 |
|
| 861 |
bool signatureCachedIndividualNodeBlock(CIndividualProcessNode*& indi, CIndividualNodeBlockingTestData* blockData, CIndividualProcessNode*& blockerIndiNode, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 862 |
bool continueIndividualNodeBlock(CIndividualProcessNode*& indi, CIndividualNodeBlockingTestData* blockData, CIndividualProcessNode*& blockerIndiNode, CBlockingAlternativeData** blockAltData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 863 |
void reactivateIndirectBlockedSuccessors(CIndividualProcessNode*& indi, bool recursive, CCalculationAlgorithmContextBase* calcAlgContext); |
| 864 |
|
| 865 |
bool reactivateBlockedIndividuals(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 866 |
|
| 867 |
|
| 868 |
|
| 869 |
void propagateIndividualProcessedAndReactivate(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 870 |
void searchReactivateIndividualsProcessedPropagated(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 871 |
|
| 872 |
void propagateIndividualUnprocessed(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 873 |
void propagateIndividualUnprocessed(CIndividualProcessNode*& indi, bool requiresConsFlag, CCalculationAlgorithmContextBase* calcAlgContext); |
| 874 |
|
| 875 |
CCalculationAlgorithmContextBase* createCalculationAlgorithmContext(CTaskProcessorContext *processorContext, CProcessContext* processContext, CSatisfiableCalculationTask* satCalcTask); |
| 876 |
|
| 877 |
|
| 878 |
void createIndividualNodeDisjointRolesLinks(CIndividualProcessNode*& sourceIndi, CIndividualProcessNode*& destinationIndi, CSortedNegLinker<CRole*>* disjointRoleLinker, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 879 |
void createIndividualNodeNegationLink(CIndividualProcessNode*& sourceIndi, CIndividualProcessNode*& destinationIndi, CRole* negationRole, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 880 |
|
| 881 |
bool areIndividualNodesDisjointRolesMergeable(CIndividualProcessNode* indi1, CIndividualProcessNode* indi2, CClashedDependencyDescriptor*& clashDescriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 882 |
bool isIndividualNodeDisjointRolesMergeable(CIndividualProcessNode* indi1, CIndividualProcessNode* indi2, CClashedDependencyDescriptor*& clashDescriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 883 |
|
| 884 |
|
| 885 |
void propagateIndirectSuccessorSaturationBlocked(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 886 |
bool validateSaturationCachingPossible(CIndividualProcessNode* indi, CIndividualSaturationProcessNode*& saturationIndiNode, bool* satCachingPossible, CConceptDescriptor** lastSatCachPossibleConDes, CConcept* addedConcept, bool addedConceptNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 887 |
bool tryExpansionFromSaturatedData(CIndividualProcessNode*& indi, CIndividualProcessNode* createdSuccIndi, CConceptDescriptor* conDes, CDependencyTrackPoint* depTrackPoint, CIndividualSaturationProcessNode*& saturationIndiNode, bool* satCachingPossible, CConceptDescriptor** lastSatCachPossibleConDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 888 |
bool tryEstablishSaturationCaching(CIndividualProcessNode*& indi, CIndividualProcessNode* succIndi, CIndividualSaturationProcessNode* saturationIndiNode, bool* satCachingPossible, CConceptDescriptor** lastSatCachPossibleConDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 889 |
CIndividualProcessNode* getSuccessorIndividual(CIndividualProcessNode*& indi, CIndividualLinkEdge* link, CCalculationAlgorithmContextBase* calcAlgContext); |
| 890 |
CIndividualProcessNode* getLocalizedSuccessorIndividual(CIndividualProcessNode*& indi, CIndividualLinkEdge* link, CCalculationAlgorithmContextBase* calcAlgContext); |
| 891 |
CIndividualProcessNode* createSuccessorIndividual(CIndividualProcessNode*& indi, CConceptDescriptor* conDes, CSortedNegLinker<CRole*>* roleLinkerIt, CRole* ancRole, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, CDependencyTrackPoint* depTrackPoint, CIndividualSaturationProcessNode* saturationIndiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 892 |
CIndividualProcessNode* tryExtendFunctionalSuccessorIndividual(CIndividualProcessNode*& indi, CConceptDescriptor* conDes, CSortedNegLinker<CRole*>* roleLinkerIt, CRole* ancRole, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, CDependencyTrackPoint* depTrackPoint, CIndividualSaturationProcessNode* saturationIndiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 893 |
void createDistinctSuccessorIndividuals(CIndividualProcessNode*& indi, CConceptDescriptor* conDes, CPROCESSINGLIST<CIndividualProcessNode*>& indiList, CSortedNegLinker<CRole*>* roleLinkerIt, CRole* ancRole, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, CDependencyTrackPoint* depTrackPoint, cint64 succCardCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 894 |
void createNominalsSuccessorIndividuals(CIndividualProcessNode*& indi, CSortedNegLinker<CRole*>* roleLinkerIt, CRole* ancRole, CSortedNegLinker<CConcept*>* conceptLinkerIt, bool negate, CDependencyTrackPoint* depTrackPoint, cint64 succCardCount, CCalculationAlgorithmContextBase* calcAlgContext); |
| 895 |
CIndividualSaturationProcessNode* getCreationSuccessorSaturationNode(CIndividualProcessNode*& indi, CConceptDescriptor* conDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 896 |
CIndividualSaturationProcessNode* getSaturationResolvedIndividualNodeExtension(CSaturationIndividualNodeExtensionResolveData* resolveData, CPROCESSINGHASH<cint64, CConceptNegationPair>* conExtensionMap, CCalculationAlgorithmContextBase* calcAlgContext); |
| 897 |
void collectReapplyAutomatTransactionsRestrictions(CIndividualProcessNode*& processIndi, CRole* collectingRole, CConcept* concept, bool negated, CPROCESSINGHASH<cint64, CConceptNegationPair>*& conExtensionMap, CReapplyConceptSaturationLabelSet* conSet, CCalculationAlgorithmContextBase* calcAlgContext); |
| 898 |
|
| 899 |
|
| 900 |
|
| 901 |
bool tryInitalizingFromSaturatedData(CIndividualProcessNode*& indi, CXSortedNegLinker<CConcept*>* initConceptLinker, CDependencyTrackPoint* depTrackPoint, bool allowPreprocess, CCalculationAlgorithmContextBase* calcAlgContext); |
| 902 |
|
| 903 |
|
| 904 |
|
| 905 |
|
| 906 |
|
| 907 |
|
| 908 |
|
| 909 |
|
| 910 |
|
| 911 |
|
| 912 |
|
| 913 |
bool hasNondeterministicDependency(CDependencyTrackPoint* dependencyTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 914 |
|
| 915 |
|
| 916 |
|
| 917 |
|
| 918 |
|
| 919 |
|
| 920 |
|
| 921 |
|
| 922 |
|
| 923 |
|
| 924 |
bool prepareBackendExpansionReuseBranching(CCalculationAlgorithmContextBase* calcAlgContext); |
| 925 |
bool prepareBackendIndividualFixedReuseExpansion(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 926 |
bool prepareBackendIndividualPrioritizedReuseExpansion(CIndividualProcessNode*& indiProcNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 927 |
bool reuseIndividualBackendExpansion(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 928 |
bool checkIndividualBackendExpansionReuseable(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 929 |
|
| 930 |
|
| 931 |
|
| 932 |
CIndividualProcessNode* queuedIndividualBackendNeighbourExpansion(CIndividualProcessNode*& baseIndiNode, CBackendNeighbourExpansionControllingData* expContData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 933 |
|
| 934 |
bool canDelayRepresentativeNeighbourExpansion(CIndividualProcessNode* expIndiNode, CBackendNeighbourExpansionQueueDataLinker* backendNeighbourExpDataLinker, CPROCESSHASH<CBackendRepresentativeMemoryLabelCacheItem *, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData>* labelNeighbourExpDelayDataHash, CBackendRepresentativeMemoryLabelCacheItem* expandingLabel, CBackendRepresentativeMemoryCacheIndividualAssociationData* neighbourAssData, cint64 arrayPos, cint64 lastCursor, cint64 neighbourIndiId, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData*& labelNeighbourExpansionData, bool& expansionDelaying, bool& representativeExpansion, CCalculationAlgorithmContextBase* calcAlgContext); |
| 935 |
bool delayingRepresentativeNeighbourExpansion(CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, bool expansionDelaying, bool representativeExpansion, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData* labelNeighbourExpansionData, cint64 lastCursor, cint64 neighbourIndiId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 936 |
|
| 937 |
bool markIndividualNodeBackendNonConceptSetNeighbourLabelRelatedProcessingForDisjointRoles(CIndividualProcessNode* indiNode, CRole* role, CCalculationAlgorithmContextBase* calcAlgContext); |
| 938 |
bool markIndividualNodeBackendNonConceptSetNeighbourLabelRelatedProcessing(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 939 |
bool markIndividualNodeBackendNonConceptSetRelatedAndNeighbourLabelRelatedProcessing(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 940 |
bool markIndividualNodeBackendNonConceptSetRelatedAndNeighbourLabelRelatedProcessingForDisjointRoles(CIndividualProcessNode* indiNode, CRole* role, CCalculationAlgorithmContextBase* calcAlgContext); |
| 941 |
|
| 942 |
|
| 943 |
CIndividualProcessNode* getLocalizedForcedBackendInitializedNominalIndividualNode(cint64 nominalId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 944 |
CIndividualProcessNode* getLocalizedForcedBackendInitializedNominalIndividualNode(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 945 |
|
| 946 |
bool loadIndividualNodeDataFromBackendCache(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 947 |
bool initializeIndividualNodeWithBackendCache(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 948 |
bool tryEstablishExpansionBlockingWithBackendCacheSynchronisation(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 949 |
bool tryDelayIndividualNodeInitializationWithBackendConceptSetLabel(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 950 |
bool markIndividualNodeBackendNonConceptSetRelatedProcessing(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 951 |
bool markIndividualNodeBackendNonConceptSetRelatedProcessingForDisjointRoles(CIndividualProcessNode* indiNode, CRole* role, CCalculationAlgorithmContextBase* calcAlgContext); |
| 952 |
CIndividualRepresentativeBackendCacheConceptSetLabelProcessingHasher getIndividualRepresentativeBackendCacheConceptSetLabelProcessingHasher(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 953 |
CIndividualRepresentativeBackendCacheConceptSetLabelProcessingHasher getIndividualRepresentativeBackendCacheConceptSetLabelProcessingHasher(CBackendRepresentativeMemoryCacheIndividualAssociationData* indiAssData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 954 |
|
| 955 |
bool visitIndividualsRelevantMergingsBackendSynchronisationDataIndividuals(CIndividualProcessNode* indiNode, CXLinker<cint64>* mergedIndiLinker, CXLinker<cint64>* lastProcessedMergedIndiLinker, bool localize, function<bool(CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* locBackendSyncDataIndiNode, CDependencyTrackPoint* backSyncDepTrackPoint)> visitFunc, CCalculationAlgorithmContextBase* calcAlgContext); |
| 956 |
bool visitIndividualsRelevantBackendSynchronisationDataIndividuals(CIndividualProcessNode* indiNode, bool localize, function<bool(CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* locBackendSyncDataIndiNode, CDependencyTrackPoint* backSyncDepTrackPoint)> visitFunc, CCalculationAlgorithmContextBase* calcAlgContext); |
| 957 |
bool visitNewlyMergedIndividualsBackendSynchronisationData(CIndividualProcessNode* indiNode, CPROCESSHASH<CIndividualProcessNode*, CDependencyTrackPoint*>* newIndiMergedHash, bool visitBaseIndividual, function<bool(CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* locBackendSyncDataIndiNode, CDependencyTrackPoint* backSyncDepTrackPoint)> visitFunc, CCalculationAlgorithmContextBase* calcAlgContext); |
| 958 |
bool visitNewlyMergedIndividualsBackendSynchronisationData(CIndividualProcessNode* indiNode, CXLinker<CIndividualProcessNode*>* newIndiMergedLinker, CXLinker<CIndividualProcessNode*>* prevIndiMergedLinker, bool visitBaseIndividual, function<bool(CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* locBackendSyncDataIndiNode, CDependencyTrackPoint* backSyncDepTrackPoint)> visitFunc, CCalculationAlgorithmContextBase* calcAlgContext); |
| 959 |
bool visitNewlyMergedOnlyDeterministicRepresentativeIndividualsBackendSynchronisationData(CIndividualProcessNode* indiNode, CXLinker<CIndividualProcessNode*>* newIndiMergedLinker, CXLinker<CIndividualProcessNode*>* prevIndiMergedLinker, bool visitBaseIndividual, function<bool(CIndividualProcessNode* baseIndiNode, CIndividualProcessNode* locBackendSyncDataIndiNode, CDependencyTrackPoint* backSyncDepTrackPoint)> visitFunc, CCalculationAlgorithmContextBase* calcAlgContext); |
| 960 |
|
| 961 |
bool validateBackendSynchronisationContinued(CIndividualProcessNode* indi, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData, CConcept* addedConcept, bool addedConceptNegation, CCalculationAlgorithmContextBase* calcAlgContext); |
| 962 |
bool testIndividualNodeBackendCacheConceptsSynchronization(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 963 |
bool testIndividualNodeBackendCacheNeighbourExpansionBlockingCritical(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 964 |
bool testIndividualNodeBackendCacheSameMergedBlockingCritical(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 965 |
|
| 966 |
bool testIndividualNodeBackendCacheNewMergings(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 967 |
bool testIndividualNodeConceptBackendCacheNeighbourExpansionBlockingCritical(CConcept* concept, bool conNegation, bool nondeterministic, CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 968 |
bool debugCheckDirectlyInfluencedNeighbourWithPropagationPossible(CConcept* concept, bool conNegation, CIndividualProcessNode* indiNode, CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 969 |
|
| 970 |
bool testIndividualNodeBackendCacheExpansionBlockingCriticalCardinality(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 971 |
bool testIndividualNodeBackendCacheNominalIndirectConnectionBlockingCritical(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 972 |
cint64 getBackendCacheRoleRepresentativeNeighbourCount(CIndividualProcessNode* indiNode, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* backendSyncData, CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData, CRole* role, CCalculationAlgorithmContextBase* calcAlgContext); |
| 973 |
|
| 974 |
bool expandDirectlyInfluencedIndividualNeighbourNodesFromBackendCache(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 975 |
|
| 976 |
bool expandDirectlyInfluencedNeighboursWithPropagation(CConcept* concept, bool conNegation, bool nondeterministic, CIndividualProcessNode* indiNode, CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData, CIndividualProcessNode* locBackendSyncDataIndiNode, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, CDependencyTrackPoint* backSyncDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 977 |
|
| 978 |
CAnsweringPropagationSteeringController* getPropagationSteeringController(CCalculationAlgorithmContextBase* calcAlgContext); |
| 979 |
bool isNeighbourExpansionWithPropagationAllowed(CIndividualProcessNode* indiNode, CConcept* concept, bool conNegation, cint64 neighbourIndiId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 980 |
bool canExpandDirectlyInfluencedNeighbourWithPropagation(CIndividualProcessNode* indiNode, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, CDependencyTrackPoint* backSyncDepTrackPoint, CConcept* concept, bool conNegation, bool nondeterministic, CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData& neighbourExpansionData, cint64 neighbourIndiId, CBackendRepresentativeMemoryCacheIndividualAssociationData* neighbourAssData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 981 |
bool canExpansionPotentiallyInfluenceNeighbourWithPotentialPropagation(CIndividualProcessNode* indiNode, CConcept* concept, bool conNegation, bool nondeterministic, CBackendRepresentativeMemoryCacheIndividualAssociationData* assData, cint64 neighbourIndiId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 982 |
|
| 983 |
bool expandIndirectlyConnectedIndividuals(CIndividualProcessNode* indiNode, bool checkExpansionRequired, CCalculationAlgorithmContextBase* calcAlgContext); |
| 984 |
|
| 985 |
bool expandIndirectCompatibleRequiredIndividualNeighbourNodesFromBackendCache(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 986 |
bool expandIndirectCompatibleRequiredIndividualNeighbourNodesFromBackendCache(CIndividualProcessNode* indi, CIndividualProcessNode* checkingBackendSyncDataIndiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 987 |
|
| 988 |
|
| 989 |
CPROCESSHASH< QPair<CRole*, bool>, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationRoleNeighbourExpansionData >* getBackendSynchronizationFilledRoleNeighbourExpansionDataHash(CIndividualProcessNode* indiNode, CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, CCalculationAlgorithmContextBase* calcAlgContext); |
| 990 |
bool expandIndividualInferringNeighboursFromBackendCache(CIndividualProcessNode* indiNode, CIndividualProcessNode* backendSyncDataIndiNode, bool forceExpansion, CDependencyTrackPoint* backSyncDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 991 |
bool expandIndividualAllNeighboursFromBackendCache(CIndividualProcessNode* indiNode, CIndividualProcessNode* backendSyncDataIndiNode, bool forceExpansion, bool nonDeterministicConsequencesMissingExpansion, CDependencyTrackPoint* backSyncDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 992 |
bool expandIndividualNeighbourNodeFromBackendCache(CIndividualProcessNode* indiNode, CBackendRepresentativeMemoryCacheIndividualAssociationData* assocData, cint64 neighbourIndiId, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData& neighbourExpansionData, bool forceExpansion, bool forceProcessing, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData** representativeLabelExpansionData, CDependencyTrackPoint* baseDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 993 |
bool expandIndividualNeighbourNodeFromBackendCache(CIndividualProcessNode* indiNode, cint64 neighbourIndiId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 994 |
|
| 995 |
bool initializeNeighbourExpansionWithPropagation(CIndividualProcessNode* indiNode, CIndividualProcessNode* locBackendSyncDataIndiNode, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* locBackendSyncData, CDependencyTrackPoint* backSyncDepTrackPoint, cint64 arrayId, CConcept* concept, bool conNegation, bool nondeterministic, CRole* role, bool forceExpansion, bool propCutExpansion, bool nonDeterministicConsequencesMissingExpansion, CCalculationAlgorithmContextBase* calcAlgContext); |
| 996 |
bool ensureBaseLinkExpansion(CIndividualProcessNode* expIndiNode, CIndividualProcessNode* indiNode, cint64 neighbourNodeId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 997 |
|
| 998 |
CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* getLocalizedIndividualBackendCacheSnychronisationData(CIndividualProcessNode* indiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 999 |
|
| 1000 |
|
| 1001 |
void installIndividualNodeRoleLink(CIndividualProcessNode*& sourceIndi, CIndividualProcessNode*& destinationIndi, CIndividualLinkEdge* individualLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1002 |
CReapplyQueueIterator installIndividualNodeRoleLinkReapplied(CIndividualProcessNode*& sourceIndi, CIndividualProcessNode*& destinationIndi, CIndividualLinkEdge* individualLink, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1003 |
|
| 1004 |
|
| 1005 |
CIndividualProcessNode* createNewEmptyIndividual(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1006 |
|
| 1007 |
CIndividualProcessNode* createNewIndividual(CDependencyTrackPoint* depTrackPoint, bool dataNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1008 |
CIndividualLinkEdge* createNewIndividualsLink(CIndividualProcessNode*& indiCreator, CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CRole* ancRole, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1009 |
CIndividualLinkEdge* createNewIndividualsLinkReapplyed(CIndividualProcessNode*& indiCreator, CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CRole* role, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1010 |
CIndividualLinkEdge* createNewIndividualsLinks(CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CSortedNegLinker<CRole*>* roleLinkerIt, CRole* ancRole, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1011 |
CIndividualLinkEdge* createNewIndividualsLinksReapplyed(CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CSortedNegLinker<CRole*>* roleLinkerIt, CRole* ancRole, CDependencyTrackPoint* depTrackPoint, bool checkRoleExisting, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1012 |
CIndividualProcessNode* getAncestorIndividual(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1013 |
bool hasIndividualsLink(CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CRole* role, bool locateable, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1014 |
|
| 1015 |
void createIndividualsDistinct(CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1016 |
void createIndividualsDistinct(CPROCESSINGLIST<CIndividualProcessNode*>& indiList, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1017 |
|
| 1018 |
CIndividualProcessNode* getLocalizedIndividual(CIndividualProcessNode* indi, bool updateIndividual, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1019 |
CIndividualProcessNode* getLocalizedIndividual(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1020 |
CIndividualProcessNode* getUpToDateIndividual(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1021 |
CIndividualProcessNode* getUpToDateIndividual(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1022 |
CIndividualProcessNode* getAvailableUpToDateIndividual(cint64 indiID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1023 |
CIndividual* createNewTemporaryNominalIndividual(cint64 indiId, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1024 |
|
| 1025 |
CIndividualLinkEdge* getIndividualNodeLink(CIndividualProcessNode*& indiSource, CIndividualProcessNode*& indiDestination, CRole* role, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1026 |
CIndividualLinkEdge* getLinkProcessingRestriction(CConceptProcessDescriptor*& conProDes); |
| 1027 |
|
| 1028 |
|
| 1029 |
void propagateIndividualNodeNewNominalConnectionToAncestors(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1030 |
void propagateIndividualNodeNominalConnectionToAncestors(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1031 |
void propagateIndividualNodeNeighboursNominalConnectionToAncestors(CIndividualProcessNode*& indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1032 |
|
| 1033 |
void propagateIndividualNodeNominalConnectionFlagsToAncestors(CIndividualProcessNode*& indi, cint64 nominalPropagationFlags, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1034 |
|
| 1035 |
void propagateIndividualNodeConnectedNominalToAncestors(CIndividualProcessNode*& indi, cint64 nominalID, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1036 |
void propagateIndividualNodeNominalConnectionStatusToAncestors(CIndividualProcessNode*& indi, CIndividualProcessNode* copyFromIndiNode, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1037 |
|
| 1038 |
|
| 1039 |
bool expandBackendCacheIndividualNodesNominalMerging(CIndividualProcessNode* indi1, CIndividualProcessNode* indi2, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1040 |
bool expandBackendCacheIndividualNodesNominalMergingNeighbouringConnections(CIndividualProcessNode* indi1, CIndividualProcessNode* indi2, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1041 |
|
| 1042 |
bool isIndividualNodesMergeable(CIndividualProcessNode* indi1, CIndividualProcessNode* indi2, CClashedDependencyDescriptor*& clashDescriptors, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1043 |
bool isIndividualNodesMergeableWithoutNewRuleApplications(CIndividualProcessNode* mergeIntoIndi1, CIndividualProcessNode* indi2, bool* mergingPossiblyRequiresRuleApplications, bool cancelOnPossiblyNewRuleApplications, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1044 |
|
| 1045 |
|
| 1046 |
CIndividualProcessNode* getMergedIndividualNodes(CIndividualProcessNode*& preferedMergeIntoIndividualNode, CIndividualProcessNode*& individual2, CDependencyTrackPoint* mergeDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1047 |
void mergeIndividualNodeInto(CIndividualProcessNode*& mergeIntoIndividualNode, CIndividualProcessNode*& individual, CDependencyTrackPoint* mergeDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1048 |
CIndividualProcessNode* getIntoEmptyMergedIndividualNode(CIndividualProcessNode*& mergingIndividualNode, bool createAsNominal, CIndividualProcessNode* mergerNode, CDependencyTrackPoint* mergeDepTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1049 |
|
| 1050 |
|
| 1051 |
|
| 1052 |
QString writeGeneratedExtendedDebugIndiModelStringList(const QString& filename, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1053 |
|
| 1054 |
QString generateDebugIndiModelStringList(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1055 |
QString generateExtendedDebugIndiModelStringList(CCalculationAlgorithmContextBase* calcAlgContext, QStringList* list = nullptr); |
| 1056 |
QString generateDebugIndiStatusString(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1057 |
QString generateDebugDependentNominalsString(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1058 |
QString generateDebugIncrementalExpansionString(CIndividualProcessNode* indi, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1059 |
|
| 1060 |
QString generateDebugDependencyString(CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1061 |
QStringList generateExtendedDebugConceptSetStringList(CReapplyConceptLabelSet* conSet, CConceptPropagationBindingSetHash* propBindSetHash, CConceptVariableBindingPathSetHash* varBindPathSetHash, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1062 |
void debugTestCriticalConceptSet(QStringList& conSetList, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1063 |
|
| 1064 |
|
| 1065 |
void analyzeABoxCompressionPossibilities(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1066 |
void analyzeBranchingMemoryWasting(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1067 |
|
| 1068 |
void analyzeCompletionGraphStatistics(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1069 |
void writeCompletionGraphStatistics(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1070 |
bool isConceptFromPredecessorDependent(CIndividualProcessNode*& individualNode, CConceptDescriptor* conDes, CDependencyTrackPoint* depTrackPoint, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1071 |
|
| 1072 |
void testCompletionGraphCachingAndBlocking(CCalculationAlgorithmContextBase* calcAlgContext, CIndividualProcessNode* exceptIndividualNode = nullptr); |
| 1073 |
void testProblematicConceptSet(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1074 |
|
| 1075 |
|
| 1076 |
|
| 1077 |
CConceptDescriptor* createConceptDescriptor(CCalculationAlgorithmContextBase* calcAlgContext); |
| 1078 |
void releaseConceptDescriptor(CConceptDescriptor* conDes, CCalculationAlgorithmContextBase* calcAlgContext); |
| 1079 |
|
| 1080 |
|
| 1081 |
|
| 1082 |
// protected variables |
| 1083 |
protected: |
| 1084 |
CCalculationAlgorithmContextBase* mCalcAlgContext; |
| 1085 |
CProcessingDataBox* mProcessingDataBox; |
| 1086 |
|
| 1087 |
CIndividualProcessingQueue* mProcessingQueue; |
| 1088 |
CIndividualDepthProcessingQueue* mNominalProcessingQueue; |
| 1089 |
CIndividualDepthProcessingQueue* mNominalDeterministicProcessingQueue; |
| 1090 |
|
| 1091 |
CIndividualUnsortedProcessingQueue* mDepthFirstProcessingQueue; |
| 1092 |
CIndividualUnsortedProcessingQueue* mNominalCachingLossReactivationProcessingQueue; |
| 1093 |
CSignatureBlockingReviewSet* mSigBlockRevSet; |
| 1094 |
CReusingReviewData* mReusingReviewData; |
| 1095 |
CIndividualUnsortedProcessingQueue* mIndiImmediateProQueue; |
| 1096 |
CIndividualDepthProcessingQueue* mIndiDetExpProQueue; |
| 1097 |
CIndividualUnsortedProcessingQueue* mIndiDetDeptFirstExpProQueue; |
| 1098 |
CIndividualDepthProcessingQueue* mIndiBlockReactProQueue; |
| 1099 |
CIndividualDepthProcessingQueue* mIndiSigBlockUpdProQueue; |
| 1100 |
CIndividualDepthProcessingQueue* mDepthProcessingQueue; |
| 1101 |
CIndividualReactivationProcessingQueue* mEarlyIndiReactProcessingQueue; |
| 1102 |
CIndividualReactivationProcessingQueue* mLateIndiReactProcessingQueue; |
| 1103 |
CIndividualConceptBatchProcessingQueue* mVarBindConBatchProcessingQueue; |
| 1104 |
CIndividualUnsortedProcessingQueue* mDelayedNominalProcessingQueue; |
| 1105 |
CIndividualUnsortedProcessingQueue* mRoleAssertionProcessingQueue; |
| 1106 |
CIndividualDepthProcessingQueue* mValueSpaceTriggeringProQueue; |
| 1107 |
CIndividualDepthProcessingQueue* mValueSpaceSatCheckingQueue; |
| 1108 |
CIndividualUnsortedProcessingQueue* mBackendSyncRetestProcessingQueue; |
| 1109 |
CIndividualUnsortedProcessingQueue* mBackendDirectInfluenceExpansionQueue; |
| 1110 |
CIndividualUnsortedProcessingQueue* mBackendIndirectCompatibilityExpansionQueue; |
| 1111 |
CIndividualLinkerRotationProcessingQueue* mBackendNeighbourExpansionQueue; |
| 1112 |
CIndividualUnsortedProcessingQueue* mBackendLateNeighbourExpansionQueue; |
| 1113 |
CIndividualUnsortedProcessingQueue* mBackendReuseExpansionQueue; |
| 1114 |
CIndividualDepthProcessingQueue* mIncrementalExpansionInitializingProcessingQueue; |
| 1115 |
CIndividualCustomPriorityProcessingQueue* mIncrementalExpansionProcessingQueue; |
| 1116 |
CIndividualDepthProcessingQueue* mIncrementalCompatibilityCheckingQueue; |
| 1117 |
|
| 1118 |
enum INDINODEQUEUETYPE { |
| 1119 |
INQT_NONE, INQT_CACHETEST, INQT_IMMEDIATE, INQT_DELAYEDBACKENDINIT, INQT_ROLEASS, INQT_BACKENDSYNCRETEST, INQT_BACKENDDIRECTINFLUENCEEXPANSION, INQT_BACKENDINDIRECTCOMPATIBILITYEXPANSION, INQT_DETEXP, INQT_VSTSATTESTING, INQT_VSTRIGGERING, INQT_BLOCKREACT, INQT_COMPCACHEDREACT, INQT_BLOCKUP, INQT_DEPTHNORMAL, INQT_NOMINAL, INQT_NOMINALCACHINGLOSSREACTIVATION, INQT_DEPTHFIRST, INQT_OUTDATED, INQT_VARBINDBATCHQUE, INQT_DELAYEDNOMINAL, INQT_BACKENDEXPANSIONREUSE |
| 1120 |
}; |
| 1121 |
INDINODEQUEUETYPE mIndiNodeFromQueueType; |
| 1122 |
|
| 1123 |
double mMinConceptProcessingPriorityLevel; |
| 1124 |
bool mIndiNodeConcludeUnsatCaching; |
| 1125 |
|
| 1126 |
cint64 mCurrentRecProcDepth; |
| 1127 |
cint64 mCurrentRecProcDepthLimit; |
| 1128 |
|
| 1129 |
|
| 1130 |
CIndividualAncestorDepthMaximumConceptProcessingPriorityStrategy* mIndiAncDepthMasConProcPriStr; |
| 1131 |
|
| 1132 |
CConceptProcessingPriorityStrategy* mConceptPriorityStrategy; |
| 1133 |
CIndividualProcessingPriorityStrategy* mIndividualPriorityStrategy; |
| 1134 |
CTaskProcessingPriorityStrategy* mTaskProcessingStrategy; |
| 1135 |
|
| 1136 |
CSatisfiableTaskConsistencyPreyingAnalyser mSatTaskConsAnalyser; |
| 1137 |
CSatisfiableTaskIncrementalConsistencyPreyingAnalyser mSatTaskIncConsAnalyser; |
| 1138 |
CSatisfiableTaskClassificationMessageAnalyser mClassMessAnalyser; |
| 1139 |
CSatisfiableTaskMarkerIndividualPropagationAnalyser mMarkerPropRealMessAnalyser; |
| 1140 |
CSatisfiableTaskPossibleAssertionCollectingAnalyser mPossAssCollAnalyser; |
| 1141 |
CSatisfiableTaskPropertyClassificationMessageAnalyser mSatTaskPropClassAnalyser; |
| 1142 |
CSatisfiableTaskComplexAnsweringMessageAnalyser mSatTaskCompAnswerAnalyser; |
| 1143 |
CSatisfiableTaskPropagationBindingAnsweringMessageAnalyser mSatTaskPropBindingAnswerAnalyser; |
| 1144 |
|
| 1145 |
|
| 1146 |
CClashDescriptorFactory* mClashDesFactory; |
| 1147 |
CDependencyFactory* mDependencyFactory; |
| 1148 |
CIndividualNodeManager* mIndiNodeManager; |
| 1149 |
CUnsatisfiableCacheHandler* mUnsatCacheHandler; |
| 1150 |
CSatisfiableExpanderCacheHandler* mSatExpCacheHandler; |
| 1151 |
CCompletionGraphCacheHandler* mCompGraphCacheHandler; |
| 1152 |
CReuseCompletionGraphCacheHandler* mReuseCompGraphCacheHandler; |
| 1153 |
CConceptNominalSchemaGroundingHandler* mGroundingHandler; |
| 1154 |
CUnsatisfiableCacheRetrievalStrategy* mUnsatCachRetStrategy; |
| 1155 |
CSaturationNodeExpansionCacheHandler* mSatNodeExpCacheHandler; |
| 1156 |
CDatatypeIndividualProcessNodeHandler* mDatatypeHandler; |
| 1157 |
CComputedConsequencesCacheHandler* mCompConsCacheHandler; |
| 1158 |
CIndividualNodeBackendCacheHandler* mBackendCacheHandler; |
| 1159 |
CIncrementalCompletionGraphCompatibleExpansionHandler* mIncExpHandler; |
| 1160 |
COccurrenceStatisticsCacheHandler* mOccStatsCacheHandler; |
| 1161 |
|
| 1162 |
CIndividualProcessNode* mLastUnsatCacheTestedIndiNode; |
| 1163 |
cint64 mLastUnsatCacheTestedIndiNodeConceptSetSize; |
| 1164 |
|
| 1165 |
const static cint64 mRuleFuncCount = 200; |
| 1166 |
TableauRuleFunction* mPosJumpFuncVec; |
| 1167 |
TableauRuleFunction* mNegJumpFuncVec; |
| 1168 |
|
| 1169 |
TableauRuleFunction mPosTableauRuleJumpFuncVec[mRuleFuncCount]; |
| 1170 |
TableauRuleFunction mNegTableauRuleJumpFuncVec[mRuleFuncCount]; |
| 1171 |
|
| 1172 |
bool mOptIncrementalExpansion; |
| 1173 |
bool mOptIncrementalCompatibleExpansion; |
| 1174 |
bool mOptIncrementalCachingExpansion; |
| 1175 |
|
| 1176 |
bool mOptIncrementalDeterministicExpansion; |
| 1177 |
bool mOptIncrementalNondeterministicExpansion; |
| 1178 |
|
| 1179 |
bool mConfAncestorBlockingSearch; |
| 1180 |
bool mConfAnywhereBlockingSearch; |
| 1181 |
bool mConfSaveCoreBlockingConceptsCandidates; |
| 1182 |
bool mConfAnywhereBlockingLinkedCandidateHashSearch; |
| 1183 |
bool mConfAnywhereBlockingCandidateHashSearch; |
| 1184 |
bool mConfAnywhereBlockingLazyExactHashing; |
| 1185 |
bool mConfAnywhereBlockingSomeInitializationHashing; |
| 1186 |
bool mConfSubSetBlocking; |
| 1187 |
bool mConfOptimizedSubSetBlocking; |
| 1188 |
bool mConfEqualSetBlocking; |
| 1189 |
bool mConfPairwiseEqualSetBlocking; |
| 1190 |
bool mConfSpecializedAutomateRules; |
| 1191 |
bool mConfSemanticBranching; |
| 1192 |
bool mConfAtomicSemanticBranching; |
| 1193 |
bool mConfBranchTriggering; |
| 1194 |
bool mConfStrictIndiNodeProcessing; |
| 1195 |
bool mConfIDIndiPriorization; |
| 1196 |
bool mConfPropagateNodeProcessed; |
| 1197 |
bool mConfDirectRulePreprocessing; |
| 1198 |
bool mConfLazyNewNominalGeneration; |
| 1199 |
bool mConfConsRestrictedNonStrictIndiNodeProcessing; |
| 1200 |
bool mConfUniqueNameAssumption; |
| 1201 |
bool mConfPairwiseMerging; |
| 1202 |
bool mConfRepresentativePropagationRules; |
| 1203 |
|
| 1204 |
|
| 1205 |
bool mConfBuildAllBranchingNodes; |
| 1206 |
bool mConfBuildDependencies; |
| 1207 |
bool mConfDependencyBacktracking; |
| 1208 |
bool mConfDependencyBackjumping; |
| 1209 |
|
| 1210 |
bool mConfWriteUnsatCaching; |
| 1211 |
bool mConfTestOccurUnsatCached; |
| 1212 |
bool mConfTestPrecheckUnsatCached; |
| 1213 |
bool mConfMinimizeMerging; |
| 1214 |
bool mConfTestedConceptWriteUnsatCaching; |
| 1215 |
|
| 1216 |
bool mConfLateBlockingResolving; |
| 1217 |
|
| 1218 |
|
| 1219 |
bool mConfSatExpCacheRetrieval; |
| 1220 |
bool mConfSatExpCacheConceptExpansion; |
| 1221 |
bool mConfSatExpCacheSatisfiableBlocking; |
| 1222 |
bool mConfSatExpCacheWriting; |
| 1223 |
|
| 1224 |
bool mConfSignatureMirroringBlocking; |
| 1225 |
bool mConfSignatureSaving; |
| 1226 |
|
| 1227 |
bool mOptSignatureMirroringBlockingForceSubset; |
| 1228 |
bool mOptSignatureMirroringBlockingInBlocking; |
| 1229 |
|
| 1230 |
bool mConfIndividualReusingFromSignatureBlocking; |
| 1231 |
|
| 1232 |
|
| 1233 |
bool mConfSatExpCachedDisjAbsorp; |
| 1234 |
bool mConfSatExpCachedMergAbsorp; |
| 1235 |
bool mConfSatExpCachedSuccAbsorp; |
| 1236 |
|
| 1237 |
bool mConfUnsatCachingUseFullNodeDependency; |
| 1238 |
bool mConfUnsatCachingUseNodeSignatureSet; |
| 1239 |
|
| 1240 |
bool mConfSkipANDConcepts; |
| 1241 |
|
| 1242 |
bool mConfCompletionGraphCaching; |
| 1243 |
bool mConfIgnoreBlockingCompletionGraphCachedNonBlockingNodes; |
| 1244 |
|
| 1245 |
bool mConfDelayCompletionGraphCachingReactivation; |
| 1246 |
bool mConfIndividualsBackendCacheLoading; |
| 1247 |
|
| 1248 |
bool mConfDepthOrientatedProcessing; |
| 1249 |
bool mConfCurrentIndividualQueuing; |
| 1250 |
|
| 1251 |
bool mOptProcessedNodePropagation; |
| 1252 |
bool mOptProcessedConsNodePropagation; |
| 1253 |
bool mOptConsistenceNodeMarking; |
| 1254 |
|
| 1255 |
bool mOptProcessingBlockingTests; |
| 1256 |
bool mOptConsNodeProcessingBlockingTests; |
| 1257 |
bool mOptNonStrictIndiNodeProcessing; |
| 1258 |
bool mOptDetExpPreporcessing; |
| 1259 |
|
| 1260 |
bool mConfUnsatBranchSatisfiableCaching; |
| 1261 |
bool mConfAtleastAtmostFastClashCheck; |
| 1262 |
|
| 1263 |
|
| 1264 |
bool mConfCompGraphReuseCacheRetrieval; |
| 1265 |
bool mConfCompGraphDeterministicReuse; |
| 1266 |
bool mConfCompGraphNonDeterministicReuse; |
| 1267 |
|
| 1268 |
bool mConfSaturationCachingWithNominals; |
| 1269 |
bool mConfExactNominalDependencyTracking; |
| 1270 |
bool mConfConceptUnsatisfiabilitySaturatedTesting; |
| 1271 |
bool mConfSaturationSatisfiabilitiyExpansionCacheWriting; |
| 1272 |
bool mConfSaturationExpansionCacheReading; |
| 1273 |
bool mConfSaturationCachingTestingDuringBlockingTests; |
| 1274 |
bool mConfSaturationConceptUnsatisfiabilitySaturatedCacheWriting; |
| 1275 |
bool mConfSaturationIncompleteExpansionFromCache; |
| 1276 |
|
| 1277 |
|
| 1278 |
bool mConfCollectCachingUpdatedBlockableIndiNodes; |
| 1279 |
|
| 1280 |
|
| 1281 |
bool mConfDatatypeReasoning; |
| 1282 |
|
| 1283 |
|
| 1284 |
bool mConfCacheComputedConsequences; |
| 1285 |
bool mConfAddCachedComputedConsequences; |
| 1286 |
|
| 1287 |
|
| 1288 |
bool mConfAnalogousPropagationPathBlockingWithAnsweringPropagationAdapters; |
| 1289 |
bool mOptAnalogousPropagationPathBlocking; |
| 1290 |
|
| 1291 |
|
| 1292 |
bool mConfDelayedBackendInitializiation; |
| 1293 |
bool mOptDelayedBackendInitializiation; |
| 1294 |
bool mOptDelayedBackendInitializiationWithRootLinkers; |
| 1295 |
|
| 1296 |
|
| 1297 |
|
| 1298 |
|
| 1299 |
bool mConfAllowBackendSuccessorExpansionBlocking; |
| 1300 |
bool mConfAllowBackendNeighbourExpansionBlocking; |
| 1301 |
bool mConfOnlyDeterministicRepresentativeBackendIndividualDataConsideration; |
| 1302 |
|
| 1303 |
|
| 1304 |
bool mConfOccurrenceStatisticsCollecting; |
| 1305 |
bool mOptCollectOccurrenceStatistics; |
| 1306 |
|
| 1307 |
|
| 1308 |
bool mConfDebuggingWriteData; |
| 1309 |
bool mConfDebuggingWriteDataComplationTasks; |
| 1310 |
bool mConfDebuggingWriteDataOnlyOnSatisfiability; |
| 1311 |
bool mConfDebuggingWriteDataForConsistencyTests; |
| 1312 |
bool mConfDebuggingWriteDataForClassificationTests; |
| 1313 |
bool mConfDebuggingWriteDataForIncrementalExpansionTests; |
| 1314 |
bool mConfDebuggingWriteDataForRepCacheIndiComputationTests; |
| 1315 |
bool mConfDebuggingWriteDataForAnsweringPropagationTests; |
| 1316 |
bool mConfDebuggingWriteDataForAllTests; |
| 1317 |
bool mDebug = false; |
| 1318 |
bool mBacktrackDebug; |
| 1319 |
|
| 1320 |
bool mConfBranchingStatisticsAnalysing; |
| 1321 |
CBranchTreeNode* mLastAnalysingBranchNodeTree; |
| 1322 |
|
| 1323 |
|
| 1324 |
|
| 1325 |
|
| 1326 |
bool mConfExpandCreatedSuccessorsFromSaturation; |
| 1327 |
bool mConfSuccessorSaturationExpansionRestrictionsResolving; |
| 1328 |
bool mConfCachingBlockingFromSaturation; |
| 1329 |
|
| 1330 |
bool mConfMergeConstructedIndividualNode; |
| 1331 |
bool mOptMergeConstructedIndividualNode; |
| 1332 |
|
| 1333 |
|
| 1334 |
|
| 1335 |
|
| 1336 |
|
| 1337 |
|
| 1338 |
bool mConfVariableBindingSteeringBackendNeighbourExpansion; |
| 1339 |
bool mConfBackendExpansionReuse; |
| 1340 |
bool mConfBackendExpansionLimitReachedReuseActivation; |
| 1341 |
bool mConfBackendExpansionLateDynamicReuseActivation; |
| 1342 |
cint64 mConfBackendExpansionSameIndividualCountReuseActivation; |
| 1343 |
cint64 mConfBackendExpansionNeighbourIndividualCountReuseActivation; |
| 1344 |
bool mConfLimitBackendNeighbourExpansion; |
| 1345 |
bool mConfAllProblematicBackendNeighbourDirectExpansion; |
| 1346 |
cint64 mConfMinBackendNeighbourDirectExpansionCount; |
| 1347 |
cint64 mOptMinBackendNeighbourDirectExpansionCount; |
| 1348 |
|
| 1349 |
cint64 mConfMinDirectNeighbourExpansionOverCriticalReductionSize; |
| 1350 |
cint64 mOptMinDirectNeighbourExpansionOverCriticalReductionSize; |
| 1351 |
|
| 1352 |
|
| 1353 |
cint64 mConfMaxBackendNeighbourTotalExpansionCount; |
| 1354 |
cint64 mOptMaxBackendNeighbourTotalExpansionCount; |
| 1355 |
cint64 mConfCriticalBackendNeighbourTotalExpansionCount; |
| 1356 |
cint64 mOptCriticalBackendNeighbourTotalExpansionCount; |
| 1357 |
cint64 mConfQueuedBackendNeighbourExpansionIndisBatchSize; |
| 1358 |
cint64 mOptQueuedBackendNeighbourExpansionIndisBatchSize; |
| 1359 |
cint64 mConfQueuedBackendNeighbourExpansionRolesBatchCount; |
| 1360 |
cint64 mOptQueuedBackendNeighbourExpansionRolesBatchCount; |
| 1361 |
|
| 1362 |
bool mConfAtmostAllDirectBackendNeighbourExpansion; |
| 1363 |
cint64 mConfDefaultIndividualPrecomputationCount; |
| 1364 |
|
| 1365 |
bool mConfNeighbourLabelRepresentativeExpansionDelaying; |
| 1366 |
bool mOptNeighbourLabelRepresentativeExpansionDelaying; |
| 1367 |
|
| 1368 |
bool mOptLimitBackendNeighbourExpansion; |
| 1369 |
bool mOptBackendExpansionReuse; |
| 1370 |
|
| 1371 |
bool mConfNewMergingsOnlyInferringExpansion; |
| 1372 |
|
| 1373 |
bool mConfExpandDeterministicMergedHandledNeighbours = true; |
| 1374 |
bool mConfCardinalityNeighbourExpansionRepresentativeCounting = false; |
| 1375 |
|
| 1376 |
|
| 1377 |
|
| 1378 |
|
| 1379 |
|
| 1380 |
bool mConfGenerateQueries; |
| 1381 |
|
| 1382 |
|
| 1383 |
|
| 1384 |
cint64 mMaxBlockingCachingSavedCandidateCount; |
| 1385 |
|
| 1386 |
cint64 mMapComparisonDirectLookupFactor; |
| 1387 |
|
| 1388 |
|
| 1389 |
CCalculationConfigurationExtension *mLastConfig; |
| 1390 |
|
| 1391 |
|
| 1392 |
QSet<cint64> mUnsatCachingSignatureSet; |
| 1393 |
|
| 1394 |
|
| 1395 |
cint64 mProcessRuleToTaskProcessingVerificationCount; |
| 1396 |
cint64 mRemainProcessRuleToTaskProcessingVerification; |
| 1397 |
|
| 1398 |
|
| 1399 |
|
| 1400 |
|
| 1401 |
cint64 mStatRepresentativeExpansionTryingNeighbourIndividualCount = 0; |
| 1402 |
cint64 mStatRepresentativeExpandedNeighbourIndividualCount = 0; |
| 1403 |
cint64 mStatRepresentativeExpansionAlreadyExistingNeighbourIndividualCount = 0; |
| 1404 |
cint64 mStatRepresentativeDelayedNeighbourIndividualExpansionCount = 0; |
| 1405 |
|
| 1406 |
|
| 1407 |
|
| 1408 |
bool mConfPossibleInstanceIndividualsMerging; |
| 1409 |
|
| 1410 |
|
| 1411 |
|
| 1412 |
static const cint64 mDeterministicProcessPriority = 4; |
| 1413 |
static const cint64 mImmediatelyProcessPriority = 8; |
| 1414 |
|
| 1415 |
// for debugging |
| 1416 |
QHash<cint64,cint64> mIndiNodeInitConceptSigCountHash; |
| 1417 |
QHash<cint64,cint64> mClosedBranchLevelCountHash; |
| 1418 |
QHash<cint64,cint64> mSignatureIndiNodeStatusHash; |
| 1419 |
QHash<cint64,cint64> mSignatureIndiNodePredDepHash; |
| 1420 |
QMap<cint64,cint64> mIndiNodeCountMap; |
| 1421 |
QList<cint64> mIndiNodeCountList; |
| 1422 |
|
| 1423 |
QSet<QString> mCriticalConceptSetStringSet; |
| 1424 |
bool mFoundCriticalConceptSet; |
| 1425 |
|
| 1426 |
static const cint64 mDebugTaskIDVectorSize = 100; |
| 1427 |
cint64 mDebugTaskIDVector[mDebugTaskIDVectorSize]; |
| 1428 |
cint64 mBacktrackingStep; |
| 1429 |
|
| 1430 |
TableauRuleFunction mLastJumpFunc; |
| 1431 |
|
| 1432 |
CBranchingMergingProcessingRestrictionSpecification* lastBranchingMergingProcRest; |
| 1433 |
|
| 1434 |
QStringList mDebugIndiModelStringList; |
| 1435 |
QString mDebugIndiModelString; |
| 1436 |
|
| 1437 |
QString mBeginTaskDebugIndiModelString; |
| 1438 |
QString mBeforeRuleDebugIndiModelString; |
| 1439 |
QString mAfterRuleDebugIndiModelString; |
| 1440 |
QString mClashedDebugIndiModelString; |
| 1441 |
QString mEndTaskDebugIndiModelString; |
| 1442 |
QString mIncExpCompIndiModelString; |
| 1443 |
QString mIncExpMergedIndiModelString; |
| 1444 |
|
| 1445 |
QString mBeforeMergingTaskDebugIndiModelString; |
| 1446 |
QString mAfterMergingTaskDebugIndiModelString; |
| 1447 |
|
| 1448 |
|
| 1449 |
QStringList mMergedStringList; |
| 1450 |
|
| 1451 |
|
| 1452 |
QString mSatTaskDebugIndiModelString; |
| 1453 |
QString mBeforeRuleTaskDebugIndiModelString; |
| 1454 |
|
| 1455 |
|
| 1456 |
QString mBeginBacktrackingClashString; |
| 1457 |
QString mBeginBacktrackingTracklineString; |
| 1458 |
QString mEndBacktrackingTracklineString; |
| 1459 |
|
| 1460 |
QString mFileBacktrackingStepTracklineString; |
| 1461 |
QString mBeginBacktrackingStepTracklineString; |
| 1462 |
QString mEndBacktrackingStepTracklineString; |
| 1463 |
|
| 1464 |
QString mBeginDetPrevBacktrackingStepTracklineString; |
| 1465 |
QString mEndDetPrevBacktrackingStepTracklineString; |
| 1466 |
QString mBeginNonDetPrevBacktrackingStepTracklineString; |
| 1467 |
QString mEndNonDetPrevBacktrackingStepTracklineString; |
| 1468 |
|
| 1469 |
|
| 1470 |
QString mNonDetDependencyTrackPointReasonString; |
| 1471 |
QString mNonDetDependencyBeforeProcessedTrackedString; |
| 1472 |
QString mNonDetDependencyCollectedTrackedString; |
| 1473 |
|
| 1474 |
QString mMergingClashString; |
| 1475 |
QString mCachingClashString; |
| 1476 |
QString mSortedCachingClashString; |
| 1477 |
|
| 1478 |
|
| 1479 |
QString mMergingQueueString; |
| 1480 |
|
| 1481 |
QString mBranchLevelClosedCountString; |
| 1482 |
QString mBeforeGroundingDebugIndiModelString; |
| 1483 |
QString mAfterGroundingDebugIndiModelString; |
| 1484 |
|
| 1485 |
|
| 1486 |
|
| 1487 |
QString mAnalogousPropagationBlockingTestingIndiAssociatedConceptsString; |
| 1488 |
QString mAnalogousPropagationBlockingBlockingIndiAssociatedConceptsString; |
| 1489 |
|
| 1490 |
QString mAnalogousPropagationBlockingTestingIndiAllAssociatedConceptsString; |
| 1491 |
QString mAnalogousPropagationBlockingBlockingIndiAllAssociatedConceptsString; |
| 1492 |
|
| 1493 |
|
| 1494 |
|
| 1495 |
cint64 mAppliedALLRuleCount; |
| 1496 |
cint64 mAppliedSOMERuleCount; |
| 1497 |
cint64 mAppliedANDRuleCount; |
| 1498 |
cint64 mAppliedORRuleCount; |
| 1499 |
cint64 mAppliedATLEASTRuleCount; |
| 1500 |
cint64 mAppliedATMOSTRuleCount; |
| 1501 |
cint64 mAppliedTOTALRuleCount; |
| 1502 |
|
| 1503 |
|
| 1504 |
cint64 mStatVarBindingCreatedCount; |
| 1505 |
cint64 mStatVarBindingGroundingCount; |
| 1506 |
cint64 mStatVarBindingImplicationCount; |
| 1507 |
cint64 mStatVarBindingJoinCombinesCount; |
| 1508 |
cint64 mStatVarBindingPropagateSuccCount; |
| 1509 |
cint64 mStatVarBindingPropagateSuccFreshCount; |
| 1510 |
cint64 mStatVarBindingPropagateSuccInitialCount; |
| 1511 |
cint64 mStatVarBindingPropagateCount; |
| 1512 |
cint64 mStatVarBindingPropagateFreshCount; |
| 1513 |
cint64 mStatVarBindingPropagateInitialCount; |
| 1514 |
|
| 1515 |
|
| 1516 |
cint64 mStatRepresentativeCreatedCount; |
| 1517 |
cint64 mStatRepresentativeGroundingCount; |
| 1518 |
cint64 mStatRepresentativeImplicationCount; |
| 1519 |
cint64 mStatRepresentativeJoinCombinesCount; |
| 1520 |
cint64 mStatRepresentativeJoinCount; |
| 1521 |
cint64 mStatRepresentativeJoinedCount; |
| 1522 |
cint64 mStatRepresentativeJoinQuickFailCount; |
| 1523 |
cint64 mStatRepresentativePropagateSuccCount; |
| 1524 |
cint64 mStatRepresentativePropagateCount; |
| 1525 |
cint64 mStatRepresentativePropagateNewRepresentativeCount; |
| 1526 |
cint64 mStatRepresentativePropagateReusedRepresentativeCount; |
| 1527 |
cint64 mStatRepresentativePropagateUseRepresentativeCount; |
| 1528 |
|
| 1529 |
cint64 mStatBackPropActivationCount; |
| 1530 |
|
| 1531 |
|
| 1532 |
cint64 mStatConDesInsertionCount; |
| 1533 |
cint64 mStatConDesContainedCount; |
| 1534 |
|
| 1535 |
|
| 1536 |
|
| 1537 |
cint64 mStatPossibleInstanceMergingTryingCount; |
| 1538 |
cint64 mStatPossibleInstanceMergingCount; |
| 1539 |
cint64 mStatPossibleInstanceMergingSearchIndiCount; |
| 1540 |
cint64 mStatPossibleInstanceMergingFoundIndiCount; |
| 1541 |
cint64 mStatPossibleInstanceMergingSkipIndiCount; |
| 1542 |
cint64 mStatPossibleInstanceMergingNotMergeableCount; |
| 1543 |
cint64 mStatPossibleInstanceMergingMaybeMergeableCount; |
| 1544 |
cint64 mStatPossibleInstanceMergingSuccessSubmitCount; |
| 1545 |
cint64 mStatPossibleInstanceMergingTriviallySuccessCount; |
| 1546 |
cint64 mStatClashCount; |
| 1547 |
cint64 mStatSatisfiableCount; |
| 1548 |
cint64 mStatStoppedCount; |
| 1549 |
|
| 1550 |
|
| 1551 |
QTime mTimerBacktracing; |
| 1552 |
QTime mUnsatCacheRetrieval; |
| 1553 |
QTime mComplGraphReuseCacheRetrieval; |
| 1554 |
|
| 1555 |
|
| 1556 |
bool mNominalMerged; |
| 1557 |
cint64 mNominalMergedCount; |
| 1558 |
|
| 1559 |
cint64 mOverJumpedNonDeterministicDecisionCount; |
| 1560 |
cint64 mRelevantNonDeterministicDecisionCount; |
| 1561 |
|
| 1562 |
|
| 1563 |
|
| 1564 |
class IndiAssociatedConceptSetCacheData { |
| 1565 |
public: |
| 1566 |
QSet< QSet<CConcept*> > mConceptSet; |
| 1567 |
bool mCreated = false; |
| 1568 |
}; |
| 1569 |
QHash<CIndividualProcessNode*, IndiAssociatedConceptSetCacheData > mCachedIndiAssociatedConceptSetHash; |
| 1570 |
|
| 1571 |
|
| 1572 |
bool mFirstBlockingTestDebugWritten = false; |
| 1573 |
bool mFirstBindingCreationDebugWritten = false; |
| 1574 |
|
| 1575 |
|
| 1576 |
|
| 1577 |
QSet<cint64> mPropCuttedIndiIds; |
| 1578 |
QSet<cint64> mPropCuttedExpandedIndiIds; |
| 1579 |
|
| 1580 |
|
| 1581 |
|
| 1582 |
cint64 nextReportingExpansionCount = 1000; |
| 1583 |
cint64 lastRecomputationTaskId = 0; |
| 1584 |
cint64 lastTaskDepth = 100; |
| 1585 |
cint64 debugExpansionCount = 500; |
| 1586 |
|
| 1587 |
|
| 1588 |
// private methods |
| 1589 |
private: |
| 1590 |
|
| 1591 |
// private variables |
| 1592 |
private: |
| 1593 |
|
| 1594 |
}; |
| 1595 |
|
| 1596 |
|
| 1597 |
|
| 1598 |
}; // end namespace Algorithm |
| 1599 |
|
| 1600 |
}; // end namespace Kernel |
| 1601 |
|
| 1602 |
}; // end namespace Reasoner |
| 1603 |
|
| 1604 |
}; // end namespace Konclude |
| 1605 |
|
| 1606 |
#endif // KONCLUDE_REASONER_KERNEL_ALGORITHM_CCALCULATIONTABLEAUCOMPLETIONTASKHANDLEALGORITHM_H |