| 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_PROCESS_CINDIVIDUALPROCESSNODE_H |
| 22 |
#define KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALPROCESSNODE_H |
| 23 |
|
| 24 |
// Libraries includes |
| 25 |
|
| 26 |
|
| 27 |
// Namespace includes |
| 28 |
#include "ProcessSettings.h" |
| 29 |
#include "CProcessContext.h" |
| 30 |
#include "CIndividualProcessNodeReference.h" |
| 31 |
#include "CReapplyQueue.h" |
| 32 |
#include "CConceptLabelSet.h" |
| 33 |
#include "CRoleReapplyHash.h" |
| 34 |
#include "CConceptReapplyHash.h" |
| 35 |
#include "CRoleSuccessorHash.h" |
| 36 |
#include "CReapplyRoleSuccessorHash.h" |
| 37 |
#include "CReapplyConceptLabelSet.h" |
| 38 |
#include "CSuccessorRoleHash.h" |
| 39 |
#include "CConnectionSuccessorCorrectionHash.h" |
| 40 |
#include "CConnectionSuccessorSet.h" |
| 41 |
#include "CConceptProcessingQueue.h" |
| 42 |
#include "CLocalizationTag.h" |
| 43 |
#include "CBlockedTestTag.h" |
| 44 |
#include "CDistinctHash.h" |
| 45 |
#include "CDisjointSuccessorRoleHash.h" |
| 46 |
#include "CDependencyTracker.h" |
| 47 |
#include "CBlockingFollowSet.h" |
| 48 |
#include "CRoleBackwardPropagationHash.h" |
| 49 |
#include "CIndividualProcessNode.h" |
| 50 |
#include "CIndividualProcessNodeLinker.h" |
| 51 |
#include "CConceptProcessLinker.h" |
| 52 |
#include "CIndividualProcessNodePriority.h" |
| 53 |
|
| 54 |
#include "CIndividualNodeModelData.h" |
| 55 |
#include "CIndividualNodeBlockData.h" |
| 56 |
#include "CBlockingVariableBindingsAnalogousPropagationData.h" |
| 57 |
#include "CIndividualNodeSatisfiableCacheRetrievalData.h" |
| 58 |
#include "CIndividualNodeBackendCacheSynchronisationData.h" |
| 59 |
#include "CIndividualNodeSatisfiableCacheStoringData.h" |
| 60 |
#include "CIndividualNodeUnsatisfiableCacheRetrievalData.h" |
| 61 |
#include "CIndividualNodeAnalizedConceptExpansionData.h" |
| 62 |
#include "CSignatureBlockingIndividualNodeConceptExpansionData.h" |
| 63 |
#include "CReusingIndividualNodeConceptExpansionData.h" |
| 64 |
#include "CIndividualNodeSaturationBlockingData.h" |
| 65 |
#include "CNominalCachingLossReactivationData.h" |
| 66 |
#include "CSuccessorConnectedNominalSet.h" |
| 67 |
#include "CSuccessorIndividualATMOSTReactivationData.h" |
| 68 |
|
| 69 |
#include "CPropagationBindingSet.h" |
| 70 |
#include "CConceptPropagationBindingSetHash.h" |
| 71 |
#include "CConceptVariableBindingPathSetHash.h" |
| 72 |
#include "CConceptRepresentativePropagationSetHash.h" |
| 73 |
#include "CIndividualNodeIncrementalExpansionData.h" |
| 74 |
|
| 75 |
#include "CDatatypesValueSpaceData.h" |
| 76 |
#include "CAdditionalProcessRoleAssertionsLinker.h" |
| 77 |
#include "CAdditionalProcessDataAssertionsLinker.h" |
| 78 |
#include "CProcessAssertedDataLiteralLinker.h" |
| 79 |
#include "CIndividualMergingHash.h" |
| 80 |
|
| 81 |
// Other includes |
| 82 |
#include "Reasoner/Ontology/CConcept.h" |
| 83 |
#include "Reasoner/Ontology/CRole.h" |
| 84 |
#include "Reasoner/Ontology/CIndividual.h" |
| 85 |
#include "Reasoner/Ontology/CIRIName.h" |
| 86 |
|
| 87 |
|
| 88 |
#include "Utilities/Memory/CObjectParameterizingAllocator.h" |
| 89 |
|
| 90 |
#include "Utilities/Container/CSortedNegLinker.h" |
| 91 |
|
| 92 |
// Logger includes |
| 93 |
#include "Logger/CLogger.h" |
| 94 |
|
| 95 |
|
| 96 |
|
| 97 |
namespace Konclude { |
| 98 |
|
| 99 |
using namespace Utilities::Memory; |
| 100 |
using namespace Utilities::Container; |
| 101 |
|
| 102 |
namespace Reasoner { |
| 103 |
|
| 104 |
using namespace Ontology; |
| 105 |
|
| 106 |
namespace Kernel { |
| 107 |
|
| 108 |
namespace Process { |
| 109 |
|
| 110 |
|
| 111 |
/*! |
| 112 |
* |
| 113 |
* \class CIndividualProcessNode |
| 114 |
* \author Andreas Steigmiller |
| 115 |
* \version 0.1 |
| 116 |
* \brief TODO |
| 117 |
* |
| 118 |
*/ |
| 119 |
class CIndividualProcessNode : public CIndividualProcessNodeReference, public CLocalizationTag, public CBlockedTestTag, public CDependencyTracker { |
| 120 |
// public methods |
| 121 |
public: |
| 122 |
//! Constructor |
| 123 |
CIndividualProcessNode(CProcessContext* processContext = nullptr); |
| 124 |
|
| 125 |
|
| 126 |
CIndividualProcessNode* initIndividualProcessNode(CIndividualProcessNode* prevIndividual); |
| 127 |
|
| 128 |
CIndividualProcessNode* initIndividualProcessNodeCopy(CIndividualProcessNode* prevIndividual, bool adobtConceptLabels = true, bool adobtRoleSuccessors = false, bool adobtStatus = false); |
| 129 |
|
| 130 |
|
| 131 |
CIndividualProcessNode* setReapplyConceptLabelSet(CReapplyConceptLabelSet* reapplyConSet); |
| 132 |
|
| 133 |
CReapplyConceptLabelSet* getReapplyConceptLabelSet(bool create = true); |
| 134 |
|
| 135 |
CConceptProcessingQueue* getConceptProcessingQueue(bool create = true); |
| 136 |
|
| 137 |
CReapplyRoleSuccessorHash* getReapplyRoleSuccessorHash(bool create = true); |
| 138 |
CRoleSuccessorLinkIterator getRoleSuccessorLinkIterator(CRole* role); |
| 139 |
CRoleSuccessorLinkIterator getRoleSuccessorHistoryLinkIterator(CRole* role, CIndividualLinkEdge* lastLink); |
| 140 |
cint64 getRoleSuccessorCount(CRole* role); |
| 141 |
|
| 142 |
|
| 143 |
CRoleSuccessorIterator getRoleIterator(); |
| 144 |
|
| 145 |
CSuccessorRoleHash* getSuccessorRoleHash(bool create = true); |
| 146 |
CSuccessorRoleIterator getSuccessorRoleIterator(cint64 indiID); |
| 147 |
CSuccessorRoleIterator getSuccessorRoleIterator(CIndividualProcessNode* indiNode); |
| 148 |
|
| 149 |
bool hasSuccessorIndividualNode(cint64 indiID); |
| 150 |
bool hasSuccessorIndividualNode(CIndividualProcessNode* indiNode); |
| 151 |
|
| 152 |
|
| 153 |
|
| 154 |
bool hasDisjointRoleConnections(); |
| 155 |
CIndividualProcessNode* setDisjointRoleConnections(bool disjointRoleConnections); |
| 156 |
|
| 157 |
CDisjointSuccessorRoleHash* getDisjointSuccessorRoleHash(bool create = true); |
| 158 |
CDisjointSuccessorRoleIterator getDisjointSuccessorRoleIterator(cint64 succIndiId); |
| 159 |
CDisjointSuccessorRoleIterator getDisjointSuccessorRoleIterator(CIndividualProcessNode* indiNode); |
| 160 |
|
| 161 |
|
| 162 |
bool hasNegationDisjointToIndividual(CRole* role, cint64 destinationIndiID); |
| 163 |
bool hasNegationDisjointToIndividual(CRole* role, CIndividualProcessNode* desIndi); |
| 164 |
|
| 165 |
CIndividualProcessNode* installDisjointLink(CNegationDisjointEdge* link); |
| 166 |
CIndividualProcessNode* removeDisjointLinks(cint64 succIndiID); |
| 167 |
|
| 168 |
bool hasRoleSuccessorToIndividual(CRole* role, cint64 destinationIndiID, bool locateable); |
| 169 |
bool hasRoleSuccessorToIndividual(CRole* role, CIndividualProcessNode* desIndi, bool locateable); |
| 170 |
|
| 171 |
CIndividualLinkEdge* getRoleSuccessorToIndividualLink(CRole* role, cint64 destinationIndiID, bool locateable); |
| 172 |
CIndividualLinkEdge* getRoleSuccessorToIndividualLink(CRole* role, CIndividualProcessNode* desIndi, bool locateable); |
| 173 |
|
| 174 |
CSuccessorIterator getSuccessorIterator(); |
| 175 |
|
| 176 |
CConnectionSuccessorSet* getConnectionSuccessorSet(bool create = true); |
| 177 |
CConnectionSuccessorSetIterator getConnectionSuccessorIterator(); |
| 178 |
|
| 179 |
CReapplyQueue* getRoleReapplyQueue(CRole* role, bool create = true); |
| 180 |
CReapplyQueueIterator getRoleReapplyIterator(CRole* role, bool clearDynamicReapllyQueue = true); |
| 181 |
|
| 182 |
|
| 183 |
CCondensedReapplyQueue* getConceptReapplyQueue(CConcept* concept, bool conceptNegation, bool create = true); |
| 184 |
CCondensedReapplyQueueIterator getConceptReapplyIterator(CConcept* concept, bool conceptNegation, bool clearDynamicReapllyQueue = true); |
| 185 |
|
| 186 |
CDistinctHash* getDistinctHash(bool create = true); |
| 187 |
|
| 188 |
|
| 189 |
CIndividualLinkEdge* getLastAddedRoleLink(); |
| 190 |
|
| 191 |
cint64 installIndividualLink(CIndividualLinkEdge* link, CReapplyQueueIterator* reapplyQueueIt = nullptr); |
| 192 |
CIndividualProcessNode* removeIndividualLink(CIndividualLinkEdge* link); |
| 193 |
CIndividualProcessNode* removeIndividualConnection(CIndividualProcessNode* indi); |
| 194 |
|
| 195 |
CIndividualLinkEdge* getAncestorLink(); |
| 196 |
CIndividualProcessNode* setAncestorLink(CIndividualLinkEdge* link); |
| 197 |
bool isIndividualAncestor(CIndividualProcessNode* individual); |
| 198 |
bool hasIndividualAncestor(); |
| 199 |
|
| 200 |
|
| 201 |
CIndividualProcessNode* addBlockedIndividualsLinker(CXLinker<CIndividualProcessNode* >* linker); |
| 202 |
CXLinker<CIndividualProcessNode*>* getBlockedIndividualsLinker(); |
| 203 |
CIndividualProcessNode* setBlockedIndividualsLinker(CXLinker<CIndividualProcessNode* >* linker = nullptr); |
| 204 |
CIndividualProcessNode* clearBlockedIndividualsLinker(); |
| 205 |
bool hasBlockedIndividualsLinker(); |
| 206 |
|
| 207 |
|
| 208 |
CIndividualNodeModelData* getIndividualModelData(); |
| 209 |
CIndividualProcessNode* setIndividualModelData(CIndividualNodeModelData* individualModel); |
| 210 |
|
| 211 |
CIndividualNodeBlockData* getIndividualBlockData(bool localBlockData = false); |
| 212 |
CIndividualProcessNode* setIndividualBlockData(CIndividualNodeBlockData* individualBlock); |
| 213 |
|
| 214 |
|
| 215 |
CBlockingVariableBindingsAnalogousPropagationData* getVariableBindingsPropagationBlockingData(bool localBlockData = false); |
| 216 |
CIndividualProcessNode* setVariableBindingsPropagationBlockingData(CBlockingVariableBindingsAnalogousPropagationData* blockData); |
| 217 |
|
| 218 |
CIndividualNodeSaturationBlockingData* getIndividualSaturationBlockingData(bool localBlockData = false); |
| 219 |
CIndividualProcessNode* setIndividualSaturationBlockingData(CIndividualNodeSaturationBlockingData* individualBlock); |
| 220 |
|
| 221 |
CIndividualNodeUnsatisfiableCacheRetrievalData* getIndividualUnsatisfiableCacheRetrievalData(bool localUnsatCacheRetData = false); |
| 222 |
CIndividualProcessNode* setIndividualUnsatisfiableCacheRetrievalData(CIndividualNodeUnsatisfiableCacheRetrievalData* individualUnsatCacheRetData); |
| 223 |
|
| 224 |
CIndividualNodeSatisfiableCacheRetrievalData* getIndividualSatisfiableCacheRetrievalData(bool localCacheData = false); |
| 225 |
CIndividualProcessNode* setIndividualSatisfiableCacheRetrievalData(CIndividualNodeSatisfiableCacheRetrievalData* satCacheRetrievalData); |
| 226 |
|
| 227 |
CIndividualNodeBackendCacheSynchronisationData* getIndividualBackendCacheSynchronisationData(bool localCacheData = false); |
| 228 |
CIndividualProcessNode* setIndividualBackendCacheSynchronisationData(CIndividualNodeBackendCacheSynchronisationData* backendSyncData); |
| 229 |
|
| 230 |
CIndividualNodeSatisfiableCacheStoringData* getIndividualSatisfiableCacheStoringData(bool localCacheData = false); |
| 231 |
CIndividualProcessNode* setIndividualSatisfiableCacheStoringData(CIndividualNodeSatisfiableCacheStoringData* satCacheStoringData); |
| 232 |
|
| 233 |
|
| 234 |
CIndividualNodeAnalizedConceptExpansionData* getAnalizedConceptExpansionData(bool createOrLocalize = true); |
| 235 |
|
| 236 |
|
| 237 |
CBlockingFollowSet* getBlockingFollowSet(bool createOrLocalize = true); |
| 238 |
bool hasBlockingFollower(); |
| 239 |
|
| 240 |
|
| 241 |
CSignatureBlockingIndividualNodeConceptExpansionData* getSignatureBlockingIndividualNodeConceptExpansionData(bool localBlockingData); |
| 242 |
CIndividualProcessNode* setSignatureBlockingIndividualNodeConceptExpansionData(CSignatureBlockingIndividualNodeConceptExpansionData* individualBlockingData); |
| 243 |
|
| 244 |
CReusingIndividualNodeConceptExpansionData* getReusingIndividualNodeConceptExpansionData(bool localBlockingData); |
| 245 |
CIndividualProcessNode* setReusingIndividualNodeConceptExpansionData(CReusingIndividualNodeConceptExpansionData* individualBlockingData); |
| 246 |
|
| 247 |
|
| 248 |
cint64 getIndividualAncestorDepth(); |
| 249 |
CIndividualProcessNode* setIndividualAncestorDepth(cint64 depth); |
| 250 |
|
| 251 |
cint64 getIndividualNominalLevel(); |
| 252 |
CIndividualProcessNode* setIndividualNominalLevel(cint64 level); |
| 253 |
|
| 254 |
|
| 255 |
cint64 getIndividualNominalLevelOrAncestorDepth(); |
| 256 |
|
| 257 |
|
| 258 |
|
| 259 |
cint64 getMergedIntoIndividualNodeID(); |
| 260 |
bool hasMergedIntoIndividualNodeID(); |
| 261 |
CIndividualProcessNode* setMergedIntoIndividualNodeID(cint64 indiNodeID); |
| 262 |
|
| 263 |
|
| 264 |
|
| 265 |
|
| 266 |
|
| 267 |
bool isBlockableIndividual(); |
| 268 |
bool isNominalIndividualNode(); |
| 269 |
CIndividual* getNominalIndividual(); |
| 270 |
CIndividualProcessNode* setNominalIndividual(CIndividual* indi); |
| 271 |
|
| 272 |
|
| 273 |
enum CIndividualType { BLOCKABLEINDIVIDUALTYPE, NOMINALINDIVIDUALTYPE }; |
| 274 |
CIndividualType getIndividualType(); |
| 275 |
|
| 276 |
CIndividualProcessNode* setIndividualType(CIndividualType indiType); |
| 277 |
|
| 278 |
|
| 279 |
cint64 getIndividualNodeID(); |
| 280 |
CIndividualProcessNode* setIndividualNodeID(cint64 indiID); |
| 281 |
|
| 282 |
bool hasInitializingConcepts(); |
| 283 |
CIndividualProcessNode* clearProcessInitializingConcepts(); |
| 284 |
CXSortedNegLinker<CConcept*>* getInitializingConceptLinker(); |
| 285 |
CXSortedNegLinker<CConcept*>* getProcessInitializingConceptLinker(); |
| 286 |
CIndividualProcessNode* setInitializingConceptLinker(CXSortedNegLinker<CConcept*>* initializingConceptLinkerIt); |
| 287 |
CIndividualProcessNode* addInitializingConceptLinker(CXSortedNegLinker<CConcept*>* initializingConceptLinkerIt); |
| 288 |
|
| 289 |
bool hasAssertionConcepts(); |
| 290 |
CIndividualProcessNode* clearAssertionConcepts(); |
| 291 |
CConceptAssertionLinker* getAssertionConceptLinker(); |
| 292 |
CIndividualProcessNode* setAssertionConceptLinker(CConceptAssertionLinker* assertionConceptLinkerIt); |
| 293 |
|
| 294 |
bool hasAssertionData(); |
| 295 |
CIndividualProcessNode* clearAssertionData(); |
| 296 |
CDataAssertionLinker* getAssertionDataLinker(); |
| 297 |
CIndividualProcessNode* setAssertionDataLinker(CDataAssertionLinker* assertionDataLinker); |
| 298 |
|
| 299 |
CDataAssertionLinker* getLastProcessedAssertionDataLinker(); |
| 300 |
CIndividualProcessNode* setLastProcessedAssertionDataLinker(CDataAssertionLinker* assDataLinker); |
| 301 |
|
| 302 |
|
| 303 |
bool hasAssertedDataLiterals(); |
| 304 |
CProcessAssertedDataLiteralLinker* getAssertedDataLiteralLinker(); |
| 305 |
CIndividualProcessNode* setAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker); |
| 306 |
CIndividualProcessNode* addAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker); |
| 307 |
CIndividualProcessNode* clearAssertedDataLiterals(); |
| 308 |
|
| 309 |
CProcessAssertedDataLiteralLinker* getLastAssertedDataLiteralLinker(); |
| 310 |
CIndividualProcessNode* setLastAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker); |
| 311 |
|
| 312 |
|
| 313 |
bool hasAssertionRoles(); |
| 314 |
CIndividualProcessNode* clearAssertionRoles(); |
| 315 |
CRoleAssertionLinker* getAssertionRoleLinker(); |
| 316 |
CIndividualProcessNode* setAssertionRoleLinker(CRoleAssertionLinker* assertionRoleLinkerIt); |
| 317 |
|
| 318 |
|
| 319 |
cint64 getRoleAssertionCreationID(); |
| 320 |
CIndividualProcessNode* setRoleAssertionCreationID(cint64 creationID); |
| 321 |
|
| 322 |
bool hasReverseAssertionRoles(); |
| 323 |
CIndividualProcessNode* clearReverseAssertionRoles(); |
| 324 |
CReverseRoleAssertionLinker* getReverseAssertionRoleLinker(); |
| 325 |
CIndividualProcessNode* setReverseAssertionRoleLinker(CReverseRoleAssertionLinker* reverseAssertionRoleLinkerIt); |
| 326 |
|
| 327 |
|
| 328 |
|
| 329 |
|
| 330 |
|
| 331 |
bool hasAdditionalRoleAssertionsLinker(); |
| 332 |
CIndividualProcessNode* clearAdditionalRoleAssertionsLinker(); |
| 333 |
CAdditionalProcessRoleAssertionsLinker* getAdditionalRoleAssertionsLinker(); |
| 334 |
CIndividualProcessNode* setAdditionalRoleAssertionsLinker(CAdditionalProcessRoleAssertionsLinker* reverseRoleAssertionsLinker); |
| 335 |
CIndividualProcessNode* addAdditionalRoleAssertionsLinker(CAdditionalProcessRoleAssertionsLinker* reverseRoleAssertionsLinker); |
| 336 |
|
| 337 |
|
| 338 |
|
| 339 |
bool hasAdditionalDataAssertionsLinker(); |
| 340 |
CIndividualProcessNode* clearAdditionalDataAssertionsLinker(); |
| 341 |
CAdditionalProcessDataAssertionsLinker* getAdditionalDataAssertionsLinker(); |
| 342 |
CIndividualProcessNode* setAdditionalDataAssertionsLinker(CAdditionalProcessDataAssertionsLinker* addDataAssertionsLinker); |
| 343 |
CIndividualProcessNode* addAdditionalDataAssertionsLinker(CAdditionalProcessDataAssertionsLinker* addDataAssertionsLinker); |
| 344 |
|
| 345 |
|
| 346 |
CAdditionalProcessDataAssertionsLinker* getLastProcessedAdditionalDataAssertionLinker(); |
| 347 |
CIndividualProcessNode* setLastProcessedAdditionalDataAssertionLinker(CAdditionalProcessDataAssertionsLinker* dataLiteralLinker); |
| 348 |
|
| 349 |
|
| 350 |
|
| 351 |
bool hasBaseConceptsInitialized(); |
| 352 |
CIndividualProcessNode* setBaseConceptsInitialized(bool initialized); |
| 353 |
|
| 354 |
|
| 355 |
bool hasUniversallyConnectionIndividualInitialized(); |
| 356 |
CIndividualProcessNode* setUniversallyConnectionIndividualInitialized(bool initialized); |
| 357 |
|
| 358 |
bool hasRoleAssertionsInitialized(); |
| 359 |
CIndividualProcessNode* setRoleAssertionsInitialized(bool initialized); |
| 360 |
|
| 361 |
|
| 362 |
bool hasReverseRoleAssertionsInitialized(); |
| 363 |
CIndividualProcessNode* setReverseRoleAssertionsInitialized(bool initialized); |
| 364 |
|
| 365 |
|
| 366 |
bool hasNominalIndividualTriplesAssertions(); |
| 367 |
CIndividualProcessNode* setNominalIndividualTriplesAssertions(bool hasNominalAssertions); |
| 368 |
|
| 369 |
bool areNominalIndividualTriplesAssertionsLoaded(); |
| 370 |
CIndividualProcessNode* setNominalIndividualTriplesAssertionsLoaded(bool loaded); |
| 371 |
|
| 372 |
bool isNominalIndividualRepresentativeBackendDataLoaded(); |
| 373 |
CIndividualProcessNode* setNominalIndividualRepresentativeBackendDataLoaded(bool loaded); |
| 374 |
|
| 375 |
|
| 376 |
|
| 377 |
CIndividualProcessNode* getProcessingBlockTestIndividual(); |
| 378 |
CIndividualProcessNode* clearProcessingBlockTestIndividual(); |
| 379 |
CIndividualProcessNode* setProcessingBlockTestIndividual(CIndividualProcessNode* ancestorBlockTestIndi); |
| 380 |
|
| 381 |
CIndividualProcessNode* addProcessingBlockedIndividualsLinker(CXLinker<CIndividualProcessNode*>* linker); |
| 382 |
CXLinker<CIndividualProcessNode*>* getProcessingBlockedIndividualsLinker(); |
| 383 |
CIndividualProcessNode* setIndirectBlockedIndividualsLinker(CXLinker<CIndividualProcessNode*>* linker = nullptr); |
| 384 |
|
| 385 |
|
| 386 |
|
| 387 |
CIndividualProcessNode* clearSatisfiableCachedAbsorbedDisjunctionsLinker(); |
| 388 |
CReapplyConceptDescriptor* getSatisfiableCachedAbsorbedDisjunctionsLinker(); |
| 389 |
CIndividualProcessNode* addSatisfiableCachedAbsorbedDisjunctionsLinker(CReapplyConceptDescriptor* disjunctionReapplyConDes); |
| 390 |
|
| 391 |
CIndividualProcessNode* clearSatisfiableCachedAbsorbedGeneratingLinker(); |
| 392 |
CReapplyConceptDescriptor* getSatisfiableCachedAbsorbedGeneratingLinker(); |
| 393 |
CIndividualProcessNode* addSatisfiableCachedAbsorbedGeneratingLinker(CReapplyConceptDescriptor* successorGeneratingReapplyConDes); |
| 394 |
|
| 395 |
cint64 getProcessingRestrictionFlags(); |
| 396 |
|
| 397 |
bool addProcessingRestrictionFlags(cint64 flags); |
| 398 |
bool clearProcessingRestrictionFlags(cint64 flags); |
| 399 |
bool hasProcessingRestrictionFlags(cint64 testFlags); |
| 400 |
bool hasPartialProcessingRestrictionFlags(cint64 testFlags); |
| 401 |
|
| 402 |
CConceptDescriptor* getIndividualInitializationConcept(); |
| 403 |
CIndividualProcessNode* setIndividualInitializationConcept(CConceptDescriptor* initConDes); |
| 404 |
|
| 405 |
cint64 getLastConceptCountCachedBlockingCandidate(); |
| 406 |
CIndividualProcessNode* setLastConceptCountCachedBlockingCandidate(cint64 conCount); |
| 407 |
|
| 408 |
cint64 getLastConceptCountSearchBlockingCandidate(); |
| 409 |
CIndividualProcessNode* setLastConceptCountSearchBlockingCandidate(cint64 conCount); |
| 410 |
|
| 411 |
cint64 getBlockingCachingSavedCandidateCount(); |
| 412 |
CIndividualProcessNode* setBlockingCachingSavedCandidateCount(cint64 conCount); |
| 413 |
CIndividualProcessNode* incBlockingCachingSavedCandidateCount(cint64 incCount = 1); |
| 414 |
|
| 415 |
|
| 416 |
bool isInvalidSignatureBlocking(); |
| 417 |
CIndividualProcessNode* setInvalidSignatureBlocking(bool invalid); |
| 418 |
|
| 419 |
cint64 getLastSearchBlockerCandidateCount(); |
| 420 |
CIndividualProcessNode* setLastSearchBlockerCandidateCount(cint64 canCount); |
| 421 |
|
| 422 |
cint64 getLastSearchBlockerCandidateSignature(); |
| 423 |
CIndividualProcessNode* setLastSearchBlockerCandidateSignature(cint64 signature); |
| 424 |
|
| 425 |
CIndividualProcessNode* addSuccessorIndividualNodeBackwardDependencyLinker(CXLinker<CIndividualProcessNode* >* linker); |
| 426 |
CXLinker<CIndividualProcessNode*>* getSuccessorIndividualNodeBackwardDependencyLinker(); |
| 427 |
CIndividualProcessNode* setSuccessorIndividualNodeBackwardDependencyLinker(CXLinker<CIndividualProcessNode* >* linker = nullptr); |
| 428 |
CIndividualProcessNode* clearSuccessorIndividualNodeBackwardDependencyLinker(); |
| 429 |
bool hasSuccessorIndividualNodeBackwardDependencyLinker(); |
| 430 |
|
| 431 |
bool hasBackwardDependencyToAncestorIndividualNode(); |
| 432 |
CIndividualProcessNode* setBackwardDependencyToAncestorIndividualNode(bool backwardDependency); |
| 433 |
|
| 434 |
|
| 435 |
|
| 436 |
bool hasBlockingRetestProcessingRestrictionFlags(); |
| 437 |
bool clearBlockingRetestProcessingRestrictionFlags(); |
| 438 |
|
| 439 |
bool hasBlockedProcessingRestrictionFlags(); |
| 440 |
bool hasDirectBlockedProcessingRestrictionFlags(); |
| 441 |
bool hasProcessingBlockedProcessingRestrictionFlags(); |
| 442 |
bool hasPurgedBlockedProcessingRestrictionFlags(); |
| 443 |
bool hasIndirectBlockedProcessingRestrictionFlags(); |
| 444 |
bool clearBlockedProcessingRestrictionFlags(); |
| 445 |
|
| 446 |
CRoleBackwardPropagationHash* getRoleBackwardPropagationHash(bool create = true); |
| 447 |
CIndividualProcessNodeLinker* getIndividualProcessNodeLinker(); |
| 448 |
CIndividualProcessNode* setIndividualProcessNodeLinker(CIndividualProcessNodeLinker* processNodeLinker); |
| 449 |
|
| 450 |
CConceptProcessLinker* getConceptProcessLinker(); |
| 451 |
CConceptProcessLinker* takeConceptProcessLinker(); |
| 452 |
CIndividualProcessNode* setConceptProcessLinker(CConceptProcessLinker* conProcessLinker); |
| 453 |
CIndividualProcessNode* addConceptProcessLinker(CConceptProcessLinker* conProcessLinker); |
| 454 |
CIndividualProcessNode* clearConceptProcessLinker(); |
| 455 |
|
| 456 |
bool getRequiredBackwardPropagation(); |
| 457 |
CIndividualProcessNode* setRequiredBackwardPropagation(bool requiredBackProp); |
| 458 |
|
| 459 |
bool hasSubstituteIndividualNode(); |
| 460 |
CIndividualProcessNode* getSubstituteIndividualNode(); |
| 461 |
CIndividualProcessNode* setSubstituteIndividualNode(CIndividualProcessNode* indiNode); |
| 462 |
|
| 463 |
bool isProcessingQueued(); |
| 464 |
bool isExtendedQueueProcessing(); |
| 465 |
bool isImmediatelyProcessingQueued(); |
| 466 |
bool isDeterministicExpandingProcessingQueued(); |
| 467 |
bool isRegularDepthProcessingQueued(); |
| 468 |
bool isBlockedReactivationProcessingQueued(); |
| 469 |
bool isBackendSynchronRetestProcessingQueued(); |
| 470 |
bool isIncrementalCompatibilityCheckingQueued(); |
| 471 |
bool isIncrementalExpansionQueued(); |
| 472 |
bool isBackendIndirectCompatibilityExpansionQueued(); |
| 473 |
bool isBackendDirectInfluenceExpansionQueued(); |
| 474 |
|
| 475 |
bool isBackendReuseExpansionQueued(); |
| 476 |
bool isBackendNeighbourExpansionQueued(); |
| 477 |
|
| 478 |
CIndividualProcessNode* setProcessingQueued(bool processingQueued); |
| 479 |
CIndividualProcessNode* setExtendedQueueProcessing(bool extendedQueueProcessing); |
| 480 |
CIndividualProcessNode* setImmediatelyProcessingQueued(bool immProQue); |
| 481 |
CIndividualProcessNode* setDeterministicExpandingProcessingQueued(bool detExpPro); |
| 482 |
CIndividualProcessNode* setRegularDepthProcessingQueued(bool depthPro); |
| 483 |
CIndividualProcessNode* setBlockedReactivationProcessingQueued(bool backendSyncRetest); |
| 484 |
CIndividualProcessNode* setBackendSynchronRetestProcessingQueued(bool backendSyncRetest); |
| 485 |
CIndividualProcessNode* setBackendIndirectCompatibilityExpansionQueued(bool queued); |
| 486 |
CIndividualProcessNode* setBackendDirectInfluenceExpansionQueued(bool queued); |
| 487 |
CIndividualProcessNode* setIncrementalCompatibilityCheckingQueued(bool incCompChecking); |
| 488 |
CIndividualProcessNode* setIncrementalExpansionQueued(bool incExpQueued); |
| 489 |
|
| 490 |
CIndividualProcessNode* setBackendReuseExpansionQueued(bool queued); |
| 491 |
CIndividualProcessNode* setBackendNeighbourExpansionQueued(bool queued); |
| 492 |
|
| 493 |
|
| 494 |
CIndividualProcessNode* clearProcessingQueued(); |
| 495 |
|
| 496 |
bool isDelayedNominalProcessingQueued(); |
| 497 |
bool hasNominalProcessingDelayingChecked(); |
| 498 |
|
| 499 |
CIndividualProcessNode* setDelayedNominalProcessingQueued(bool delayedProcessingQueued); |
| 500 |
CIndividualProcessNode* setNominalProcessingDelayingChecked(bool nominalProcessingDelayingChecked); |
| 501 |
|
| 502 |
CIndividualProcessNode* setAssertionInitialisationSignatureValue(cint64 sigValue); |
| 503 |
cint64 getAssertionInitialisationSignatureValue(); |
| 504 |
|
| 505 |
|
| 506 |
CIndividualProcessNode* setLastProcessingPriority(const CIndividualProcessNodePriority& priority); |
| 507 |
CIndividualProcessNodePriority getLastProcessingPriority(); |
| 508 |
CIndividualProcessNode* resetLastProcessingPriority(); |
| 509 |
|
| 510 |
bool isCachingLossNodeReactivationInstalled(); |
| 511 |
CIndividualProcessNode* setCachingLossNodeReactivationInstalled(bool reactivationInstalled); |
| 512 |
CNominalCachingLossReactivationData* getNominalCachingLossReactivationData(bool create = true); |
| 513 |
|
| 514 |
CSuccessorIndividualATMOSTReactivationData* getSuccessorIndividualATMOSTReactivationData(bool create = true); |
| 515 |
|
| 516 |
|
| 517 |
CSuccessorConnectedNominalSet* getSuccessorNominalConnectionSet(bool create = true); |
| 518 |
bool hasSuccessorConnectionToNominal(cint64 nominalID); |
| 519 |
bool addSuccessorConnectionToNominal(cint64 nominalID); |
| 520 |
|
| 521 |
|
| 522 |
CDatatypesValueSpaceData* getDatatypesValueSpaceData(bool create = true); |
| 523 |
|
| 524 |
CIndividualNodeIncrementalExpansionData* getIncrementalExpansionData(bool create = true); |
| 525 |
|
| 526 |
CIndividualProcessNode* setIncrementalExpansionID(cint64 incExpID); |
| 527 |
cint64 getIncrementalExpansionID(); |
| 528 |
|
| 529 |
|
| 530 |
CConceptPropagationBindingSetHash* getConceptPropagationBindingSetHash(bool create = true); |
| 531 |
|
| 532 |
CConceptVariableBindingPathSetHash* getConceptVariableBindingPathSetHash(bool create = true); |
| 533 |
|
| 534 |
CConceptRepresentativePropagationSetHash* getConceptRepresentativePropagationSetHash(bool create = true); |
| 535 |
|
| 536 |
|
| 537 |
CIndividualMergingHash* getIndividualMergingHash(bool create = true); |
| 538 |
|
| 539 |
CDependencyTrackPoint* getMergedDependencyTrackPoint(); |
| 540 |
CIndividualProcessNode* setMergedDependencyTrackPoint(CDependencyTrackPoint* depTrackPoint); |
| 541 |
|
| 542 |
CIndividualProcessNode* getLastMergedIntoIndividualNode(); |
| 543 |
CIndividualProcessNode* setLastMergedIntoIndividualNode(CIndividualProcessNode* indiNode); |
| 544 |
|
| 545 |
CIndividualProcessNode* setBlockerIndividualNode(CIndividualProcessNode* indiNode); |
| 546 |
CIndividualProcessNode* getBlockerIndividualNode(); |
| 547 |
|
| 548 |
CIndividualProcessNode* setFollowingIndividualNode(CIndividualProcessNode* indiNode); |
| 549 |
CIndividualProcessNode* getFollowingIndividualNode(); |
| 550 |
|
| 551 |
|
| 552 |
|
| 553 |
const static cint64 PRFDIRECTBLOCKED = Q_UINT64_C(0x1); |
| 554 |
const static cint64 PRFPROCESSINGBLOCKED = Q_UINT64_C(0x2); |
| 555 |
const static cint64 PRFINDIRECTBLOCKED = Q_UINT64_C(0x4); |
| 556 |
const static cint64 PRFPURGEDBLOCKED = Q_UINT64_C(0x8); |
| 557 |
const static cint64 PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED = Q_UINT64_C(0x10); |
| 558 |
const static cint64 PRFINVALIDBLOCKINGORCACHING = Q_UINT64_C(0x20); |
| 559 |
|
| 560 |
const static cint64 PRFBLOCKINGRETESTDUEANCESTORMODIFIED = Q_UINT64_C(0x100); |
| 561 |
const static cint64 PRFBLOCKINGRETESTDUEDIRECTMODIFIED = Q_UINT64_C(0x200); |
| 562 |
const static cint64 PRFBLOCKINGRETESTDUEBLOCKERMODIFIED = Q_UINT64_C(0x400); |
| 563 |
const static cint64 PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS = Q_UINT64_C(0x800); |
| 564 |
|
| 565 |
const static cint64 PRFPROCESSINGCOMPLETED = Q_UINT64_C(0x1000); |
| 566 |
const static cint64 PRFANCESTORALLPROCESSED = Q_UINT64_C(0x2000); |
| 567 |
|
| 568 |
const static cint64 PRFCONSNODEPREPARATIONINDINODE = Q_UINT64_C(0x10000); |
| 569 |
const static cint64 PRFCONCRETEDATAINDINODE = Q_UINT64_C(0x20000); |
| 570 |
|
| 571 |
const static cint64 PRFSATISFIABLECACHED = Q_UINT64_C(0x100000); |
| 572 |
const static cint64 PRFANCESTORSATISFIABLECACHED = Q_UINT64_C(0x200000); |
| 573 |
const static cint64 PRFRETESTSATISFIABLECACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x400000); |
| 574 |
const static cint64 PRFANCESTORSATISFIABLECACHEDABOLISHED = Q_UINT64_C(0x800000); |
| 575 |
|
| 576 |
const static cint64 PRFSIGNATUREBLOCKINGCACHED = Q_UINT64_C(0x1000000); |
| 577 |
const static cint64 PRFANCESTORSIGNATUREBLOCKINGCACHED = Q_UINT64_C(0x2000000); |
| 578 |
const static cint64 PRFRETESTSIGNATUREBLOCKINGCACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x4000000); |
| 579 |
const static cint64 PRFANCESTORSIGNATUREBLOCKINGCACHEDABOLISHED = Q_UINT64_C(0x8000000); |
| 580 |
|
| 581 |
const static cint64 PRFSATURATIONBLOCKINGCACHED = Q_UINT64_C(0x10000000); |
| 582 |
const static cint64 PRFANCESTORSATURATIONBLOCKINGCACHED = Q_UINT64_C(0x20000000); |
| 583 |
const static cint64 PRFRETESTSATURATIONBLOCKINGCACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x40000000); |
| 584 |
const static cint64 PRFANCESTORSATURATIONBLOCKINGCACHEDABOLISHED = Q_UINT64_C(0x80000000); |
| 585 |
|
| 586 |
const static cint64 PRFSATURATIONSUCCESSORCREATIONBLOCKINGCACHED = Q_UINT64_C(0x100000000); |
| 587 |
const static cint64 PRFSATURATIONBLOCKINGCACHEDINVALIDATED = Q_UINT64_C(0x200000000); |
| 588 |
const static cint64 PRFSATURATIONBLOCKINGCACHEDRETESTDUETOMODIFICATION = Q_UINT64_C(0x400000000); |
| 589 |
|
| 590 |
|
| 591 |
const static cint64 PRFCOMPLETIONGRAPHCACHED = Q_UINT64_C(0x1000000000); |
| 592 |
const static cint64 PRFCOMPLETIONGRAPHCACHINGINVALID = Q_UINT64_C(0x2000000000); |
| 593 |
const static cint64 PRFCOMPLETIONGRAPHCACHINGINVALIDATED = Q_UINT64_C(0x4000000000); |
| 594 |
const static cint64 PRFRETESTCOMPLETIONGRAPHCACHEDDUEDIRECTMODIFIED = Q_UINT64_C(0x8000000000); |
| 595 |
|
| 596 |
const static cint64 PRFCOMPLETIONGRAPHCACHEDNODELOCATED = Q_UINT64_C(0x10000000000); |
| 597 |
const static cint64 PRFCOMPLETIONGRAPHCACHEDNODEEXTENDED = Q_UINT64_C(0x20000000000); |
| 598 |
|
| 599 |
|
| 600 |
const static cint64 PRFSUCCESSORNOMINALCONNECTION = Q_UINT64_C(0x40000000000); |
| 601 |
const static cint64 PRFSUCCESSORNEWNOMINALCONNECTION = Q_UINT64_C(0x80000000000); |
| 602 |
|
| 603 |
const static cint64 PRFREUSINGINDIVIDUAL = Q_UINT64_C(0x100000000000); |
| 604 |
const static cint64 PRFANCESTORREUSINGINDIVIDUALBLOCKED = Q_UINT64_C(0x200000000000); |
| 605 |
const static cint64 PRFANCESTORREUSINGINDIVIDUALBLOCKEDABOLISHED = Q_UINT64_C(0x400000000000); |
| 606 |
|
| 607 |
const static cint64 PRFCACHEDCOMPUTEDTYPESADDED = Q_UINT64_C(0x1000000000000); |
| 608 |
|
| 609 |
|
| 610 |
|
| 611 |
const static cint64 PRFSYNCHRONIZEDBACKEND = Q_UINT64_C(0x10000000000000); |
| 612 |
const static cint64 PRFSYNCHRONIZEDBACKENDNEIGHBOUREXPANSIONBLOCKED = Q_UINT64_C(0x20000000000000); |
| 613 |
const static cint64 PRFSYNCHRONIZEDBACKENDSUCCESSOREXPANSIONBLOCKED = Q_UINT64_C(0x40000000000000); |
| 614 |
const static cint64 PRFSYNCHRONIZEDBACKENDINDIRECTNOMINALEXPANSIONBLOCKED = Q_UINT64_C(0x80000000000000); |
| 615 |
|
| 616 |
const static cint64 PRFRETESTBACKENDSYNCHRONIZATIONDUEDIRECTMODIFIED = Q_UINT64_C(0x100000000000000); |
| 617 |
|
| 618 |
const static cint64 PRFSYNCHRONIZEDBACKENNEIGHBOURDPARTIALEXPANSION = Q_UINT64_C(0x200000000000000); |
| 619 |
const static cint64 PRFSYNCHRONIZEDBACKENNEIGHBOURDFULLEXPANSION = Q_UINT64_C(0x400000000000000); |
| 620 |
const static cint64 PRFSYNCHRONIZEDBACKENPROCESSINGDELAYING = Q_UINT64_C(0x800000000000000); |
| 621 |
|
| 622 |
const static cint64 PRFBACKENDEXPANSIONREUSINGINDIVIDUAL = Q_UINT64_C(0x1000000000000000); |
| 623 |
const static cint64 PRFBACKENDEXPANSIONREUSEDISCARDED = Q_UINT64_C(0x2000000000000000); |
| 624 |
|
| 625 |
const static cint64 PRFINCREMENTALEXPANDING = Q_UINT64_C(0x4000000000000000); |
| 626 |
const static cint64 PRFINCREMENTALEXPANSIONRETESTDUEDIRECTMODIFIED = Q_UINT64_C(0x8000000000000000); |
| 627 |
|
| 628 |
|
| 629 |
const static cint64 PRFBLOCKINGRELATEDFLAGCOMPINATION = PRFDIRECTBLOCKED | PRFINDIRECTBLOCKED | PRFPROCESSINGBLOCKED | |
| 630 |
PRFBLOCKINGRETESTDUEANCESTORMODIFIED | PRFBLOCKINGRETESTDUEDIRECTMODIFIED | PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED | |
| 631 |
PRFBLOCKINGRETESTDUEBLOCKERMODIFIED | PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS; |
| 632 |
|
| 633 |
|
| 634 |
const static cint64 PRFINVALIDATEBLOCKERFLAGSCOMPINATION = PRFDIRECTBLOCKED | PRFINDIRECTBLOCKED | PRFPROCESSINGBLOCKED | PRFPURGEDBLOCKED | PRFSATISFIABLECACHED | |
| 635 |
PRFANCESTORSATISFIABLECACHED | PRFSIGNATUREBLOCKINGCACHED | PRFANCESTORSIGNATUREBLOCKINGCACHED | |
| 636 |
PRFREUSINGINDIVIDUAL | PRFANCESTORREUSINGINDIVIDUALBLOCKED | PRFANCESTORSATURATIONBLOCKINGCACHED | PRFCONCRETEDATAINDINODE; |
| 637 |
|
| 638 |
CConceptDescriptor* mDebugBlockerLastConceptDes; |
| 639 |
|
| 640 |
|
| 641 |
// protected methods |
| 642 |
protected: |
| 643 |
|
| 644 |
// protected variables |
| 645 |
protected: |
| 646 |
cint64 mIndiID; |
| 647 |
CIndividualType mIndiType; |
| 648 |
CIndividual* mNomIndi; |
| 649 |
|
| 650 |
cint64 mProcessingRestrictionFlags; |
| 651 |
|
| 652 |
cint64 indiAncDepth; |
| 653 |
cint64 mNominalLevel; |
| 654 |
|
| 655 |
CIndividualLinkEdge* mAncestorLink; |
| 656 |
|
| 657 |
cint64 mMergeIntoID; |
| 658 |
|
| 659 |
CProcessContext* mProcessContext; |
| 660 |
CMemoryAllocationManager* mMemAllocMan; |
| 661 |
CIndividualProcessNode* mPrevIndividual; |
| 662 |
|
| 663 |
CConceptProcessingQueue* mConceptProcessingQueue; |
| 664 |
CConceptProcessingQueue* mUseConceptProcessingQueue; |
| 665 |
CConceptProcessingQueue* mPrevConceptProcessingQueue; |
| 666 |
|
| 667 |
|
| 668 |
CReapplyConceptLabelSet* mReapplyConLabelSet; |
| 669 |
CReapplyConceptLabelSet* mUseReapplyConLabelSet; |
| 670 |
CReapplyConceptLabelSet* mPrevReapplyConLabelSet; |
| 671 |
|
| 672 |
CReapplyRoleSuccessorHash* mReapplyRoleSuccHash; |
| 673 |
CReapplyRoleSuccessorHash* mUseReapplyRoleSuccHash; |
| 674 |
CReapplyRoleSuccessorHash* mPrevReapplyRoleSuccHash; |
| 675 |
CSuccessorRoleHash* mSuccRoleHash; |
| 676 |
CSuccessorRoleHash* mUseSuccRoleHash; |
| 677 |
CSuccessorRoleHash* mPrevSuccRoleHash; |
| 678 |
|
| 679 |
CIndividualLinkEdge* mLastAddedLink; |
| 680 |
CIndividualProcessNode* mBlockerIndiNode; |
| 681 |
CIndividualProcessNode* mFollowingIndiNode; |
| 682 |
|
| 683 |
|
| 684 |
|
| 685 |
CConnectionSuccessorSet* mConnSuccSet; |
| 686 |
CConnectionSuccessorSet* mUseConnSuccSet; |
| 687 |
CConnectionSuccessorSet* mPrevConnSuccSet; |
| 688 |
|
| 689 |
|
| 690 |
CDistinctHash* mDistinctHash; |
| 691 |
CDistinctHash* mUseDistinctHash; |
| 692 |
CDistinctHash* mPrevDistinctHash; |
| 693 |
|
| 694 |
bool mDisjointRoleConnections; |
| 695 |
CDisjointSuccessorRoleHash* mDisjointSuccRoleHash; |
| 696 |
CDisjointSuccessorRoleHash* mUseDisjointSuccRoleHash; |
| 697 |
CDisjointSuccessorRoleHash* mPrevDisjointSuccRoleHash; |
| 698 |
|
| 699 |
CIndividualNodeSaturationBlockingData* mIndiSatBlockData; |
| 700 |
CIndividualNodeSaturationBlockingData* mPrevIndiSatBlockData; |
| 701 |
|
| 702 |
CIndividualNodeBlockData* mIndiBlock; |
| 703 |
CIndividualNodeBlockData* mPrevIndiBlock; |
| 704 |
|
| 705 |
CBlockingVariableBindingsAnalogousPropagationData* mIndiVarPropBlockData; |
| 706 |
CBlockingVariableBindingsAnalogousPropagationData* mPrevIndiVarPropBlockData; |
| 707 |
|
| 708 |
CIndividualNodeUnsatisfiableCacheRetrievalData* mIndiUnsatCacheRet; |
| 709 |
CIndividualNodeUnsatisfiableCacheRetrievalData* mPrevIndiUnsatCacheRet; |
| 710 |
|
| 711 |
CIndividualNodeAnalizedConceptExpansionData* mSigBlockIndExplData; |
| 712 |
CIndividualNodeAnalizedConceptExpansionData* mUseSigBlockIndExplData; |
| 713 |
CIndividualNodeAnalizedConceptExpansionData* mPrevSigBlockIndExplData; |
| 714 |
|
| 715 |
CSignatureBlockingIndividualNodeConceptExpansionData* mSigBlockConExpData; |
| 716 |
CSignatureBlockingIndividualNodeConceptExpansionData* mPrevSigBlockConExpData; |
| 717 |
|
| 718 |
CReusingIndividualNodeConceptExpansionData* mReusingConExpData; |
| 719 |
CReusingIndividualNodeConceptExpansionData* mPrevReusingConExpData; |
| 720 |
|
| 721 |
CBlockingFollowSet* mSigBlockFollowSet; |
| 722 |
CBlockingFollowSet* mUseSigBlockFollowSet; |
| 723 |
CBlockingFollowSet* mPrevSigBlockFollowSet; |
| 724 |
|
| 725 |
CConceptPropagationBindingSetHash* mConceptPropBindingSetHash; |
| 726 |
CConceptPropagationBindingSetHash* mUseConceptPropBindingSetHash; |
| 727 |
CConceptPropagationBindingSetHash* mPrevConceptPropBindingSetHash; |
| 728 |
|
| 729 |
CConceptVariableBindingPathSetHash* mConceptVarBindPathSetHash; |
| 730 |
CConceptVariableBindingPathSetHash* mUseConceptVarBindPathSetHash; |
| 731 |
CConceptVariableBindingPathSetHash* mPrevConceptVarBindPathSetHash; |
| 732 |
|
| 733 |
CConceptRepresentativePropagationSetHash* mConceptRepPropSetHash; |
| 734 |
CConceptRepresentativePropagationSetHash* mUseConceptRepPropSetHash; |
| 735 |
CConceptRepresentativePropagationSetHash* mPrevConceptRepPropSetHash; |
| 736 |
|
| 737 |
bool mInvalidSignatureBlocking; |
| 738 |
|
| 739 |
CConceptDescriptor* mInitConceptDescriptor; |
| 740 |
|
| 741 |
CXSortedNegLinker<CConcept*>* mInitializingConceptLinkerIt; |
| 742 |
CXSortedNegLinker<CConcept*>* mProcessInitializingConceptLinkerIt; |
| 743 |
CConceptAssertionLinker* mAssertionConceptLinkerIt; |
| 744 |
CDataAssertionLinker* mAssertionDataLinkerIt; |
| 745 |
CDataAssertionLinker* mLastProcessedAssertionDataLinker; |
| 746 |
CRoleAssertionLinker* mAssertionRoleLinkerIt; |
| 747 |
CReverseRoleAssertionLinker* mReverseAssertionRoleLinkerIt; |
| 748 |
CAdditionalProcessRoleAssertionsLinker* mAdditionalRoleAssertionsLinker; |
| 749 |
CAdditionalProcessDataAssertionsLinker* mAdditionalDataAssertionsLinker; |
| 750 |
CAdditionalProcessDataAssertionsLinker* mLastProcessedAdditionalDataAssertionsLinker; |
| 751 |
bool mRoleAssertionsInitialized; |
| 752 |
bool mReverseRoleAssertionsInitialized; |
| 753 |
cint64 mRoleAssertionCreationID; |
| 754 |
|
| 755 |
CProcessAssertedDataLiteralLinker* mAssertedDataLiteralLinker; |
| 756 |
CProcessAssertedDataLiteralLinker* mLastAssertedDataLiteralLinker; |
| 757 |
|
| 758 |
bool mBaseConceptsInitialized; |
| 759 |
bool mUniversallyConnectionIndividualInitialized; |
| 760 |
|
| 761 |
bool mNominalIndiTriplesAssertions; |
| 762 |
bool mLoadedNominalIndiTriplesAssertions; |
| 763 |
|
| 764 |
bool mLoadedNominalIndiRepresentativeBackendData; |
| 765 |
|
| 766 |
cint64 mLastConceptCountCachedBlockerCandidate; |
| 767 |
cint64 mLastConceptCountSearchBlockerCandidate; |
| 768 |
cint64 mLastSearchBlockerCandidateCount; |
| 769 |
cint64 mLastSearchBlockerCandidateSignature; |
| 770 |
cint64 mBlockingCachingSavedCandidateCount; |
| 771 |
|
| 772 |
CXLinker<CIndividualProcessNode*>* mBlockedIndividualsLinker; |
| 773 |
|
| 774 |
CXLinker<CIndividualProcessNode*>* mSuccessorIndiNodeBackwardDependencyLinker; |
| 775 |
bool mBackwardDependencyToAncestorIndividualNode; |
| 776 |
|
| 777 |
CIndividualNodeModelData* indiModel; |
| 778 |
|
| 779 |
CIndividualNodeSatisfiableCacheRetrievalData* mSatCacheRetData; |
| 780 |
CIndividualNodeSatisfiableCacheRetrievalData* mPrevSatCacheRetData; |
| 781 |
CIndividualNodeSatisfiableCacheStoringData* mSatCacheStoringData; |
| 782 |
CIndividualNodeSatisfiableCacheStoringData* mPrevSatCacheStoringData; |
| 783 |
|
| 784 |
CIndividualNodeBackendCacheSynchronisationData* mBackendSyncData; |
| 785 |
CIndividualNodeBackendCacheSynchronisationData* mPrevBackendSyncData; |
| 786 |
|
| 787 |
|
| 788 |
CIndividualProcessNode* mProcessingBlockedIndi; |
| 789 |
CXLinker<CIndividualProcessNode*>* mProcessingBlockedIndividualsLinker; |
| 790 |
|
| 791 |
|
| 792 |
CReapplyConceptDescriptor* mSatCachedAbsorbedDisjunctionsReapplyConDes; |
| 793 |
|
| 794 |
CReapplyConceptDescriptor* mSatCachedAbsorbedSuccessorReapplyConDes; |
| 795 |
|
| 796 |
CRoleBackwardPropagationHash* mRoleBackPropHash; |
| 797 |
CIndividualProcessNodeLinker* mIndiProcessLinker; |
| 798 |
CConceptProcessLinker* mConceptProcessLinker; |
| 799 |
bool mRequiredBackProp; |
| 800 |
CIndividualProcessNode* mSubstituteIndiNode; |
| 801 |
|
| 802 |
bool mExtendedQueueProcessing; |
| 803 |
bool mImmediatelyProcessingQueued; |
| 804 |
bool mDetExpProcessingQueued; |
| 805 |
bool mDepthProcessingQueued; |
| 806 |
bool mBlockedReactProcessingQueued; |
| 807 |
bool mBackendSynchronRetestProcessingQueued; |
| 808 |
bool mBackendIndirectCompatibilityExpansionQueued; |
| 809 |
bool mBackendDirectInfluenceExpansionQueued; |
| 810 |
bool mIncrementalCompatibilityCheckingQueued; |
| 811 |
bool mIncrementalExpansionQueued; |
| 812 |
bool mProcessingQueued; |
| 813 |
|
| 814 |
bool mBackendReuseExpansionQueued; |
| 815 |
bool mBackendNeighbourExpansionQueued; |
| 816 |
CIndividualProcessNodePriority mLastProcessingPriority; |
| 817 |
|
| 818 |
bool mDelayedNominalProcessingQueued; |
| 819 |
bool mNominalProcessingDelayingChecked; |
| 820 |
cint64 mAssertionInitialisationSignatureValue; |
| 821 |
|
| 822 |
|
| 823 |
bool mCachingLossNodeReactivationInstalled; |
| 824 |
CNominalCachingLossReactivationData* mUseReactivationData; |
| 825 |
CNominalCachingLossReactivationData* mLocReactivationData; |
| 826 |
|
| 827 |
CSuccessorIndividualATMOSTReactivationData* mUseSuccIndiATMOSTReactivationData; |
| 828 |
CSuccessorIndividualATMOSTReactivationData* mLocSuccIndiATMOSTReactivationData; |
| 829 |
|
| 830 |
|
| 831 |
CSuccessorConnectedNominalSet* mUseNominalConnectionSet; |
| 832 |
CSuccessorConnectedNominalSet* mLocNominalConnectionSet; |
| 833 |
|
| 834 |
|
| 835 |
|
| 836 |
CDatatypesValueSpaceData* mUseDatatypesValueSpaceData; |
| 837 |
CDatatypesValueSpaceData* mLocDatatypesValueSpaceData; |
| 838 |
|
| 839 |
|
| 840 |
CIndividualNodeIncrementalExpansionData* mUseIncExpData; |
| 841 |
CIndividualNodeIncrementalExpansionData* mLocIncExpData; |
| 842 |
cint64 mIncExpID; |
| 843 |
|
| 844 |
|
| 845 |
CIndividualMergingHash* mUseIndividualMergingHash; |
| 846 |
CIndividualMergingHash* mLocIndividualMergingHash; |
| 847 |
CDependencyTrackPoint* mMergedDepTrackPoint; |
| 848 |
CIndividualProcessNode* mLastMergedIntoIndividualNode; |
| 849 |
|
| 850 |
// private methods |
| 851 |
private: |
| 852 |
|
| 853 |
// private variables |
| 854 |
private: |
| 855 |
|
| 856 |
}; |
| 857 |
|
| 858 |
}; // end namespace Process |
| 859 |
|
| 860 |
}; // end namespace Kernel |
| 861 |
|
| 862 |
}; // end namespace Reasoner |
| 863 |
|
| 864 |
}; // end namespace Konclude |
| 865 |
|
| 866 |
#endif // KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALPROCESSNODE_H |