Debian Codegraph @

Source/Reasoner/Kernel/Process/CIndividualProcessNode.h

raw
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