Debian Codegraph @

Source/Reasoner/Kernel/Process/CProcessingDataBox.cpp

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 #include "CProcessingDataBox.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CProcessingDataBox::CProcessingDataBox(CProcessContext* processContext) : mProcessContext(processContext) {
34 mIndiProcessVector = CObjectParameterizingAllocator< CIndividualProcessNodeVector,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
35 mOntologyTopConcept = nullptr;
36 mOntologyTopDataRangeConcept = nullptr;
37 mSignatureBlockingCandidateHash = nullptr;
38 mUseSignatureBlockingCandidateHash = nullptr;
39 mPrevSignatureBlockingCandidateHash = nullptr;
40
41 mSignatureNominalDelayingCandidateHash = nullptr;
42 mUseSignatureNominalDelayingCandidateHash = nullptr;
43 mPrevSignatureNominalDelayingCandidateHash = nullptr;
44
45 mBlockingIndiNodeCandidateHash = nullptr;
46 mUseBlockingIndiNodeCandidateHash = nullptr;
47 mPrevBlockingIndiNodeCandidateHash = nullptr;
48 mBlockingIndiNodeLinkedCandidateHash = nullptr;
49 mUseBlockingIndiNodeLinkedCandidateHash = nullptr;
50 mPrevBlockingIndiNodeLinkedCandidateHash = nullptr;
51 mEarlyIndiReactProQueue = nullptr;
52 mLateIndiReactProQueue = nullptr;
53 mSignatureBlockingReviewSet = nullptr;
54 mReusingReviewSet = nullptr;
55 mUseSignatureBlockingReviewSet = nullptr;
56 mUseEarlyIndiReactProQueue = nullptr;
57 mUseLateIndiReactProQueue = nullptr;
58 mUseReusingReviewSet = nullptr;
59 mPrevSignatureBlockingReviewSet = nullptr;
60 mPrevEarlyIndiReactProQueue = nullptr;
61 mPrevReusingReviewSet = nullptr;
62 mNodeSwitchHistory = nullptr;
63 mUseNodeSwitchHistory = nullptr;
64 mPrevNodeSwitchHistory = nullptr;
65 mBranchingTree = nullptr;
66 mUseBranchingTree = nullptr;
67 mPrevBranchingTree = nullptr;
68 mIndividualNodeCacheTestingLinker = nullptr;
69 mSortedNominalNonDetProcessingNodeLinker = nullptr;
70 mSortedNominalNonDetProcessingNodesSorted = false;
71 mNominalNonDetProcessingCount = 0;
72 mIndividualNodeResolveLinker = nullptr;
73 mBlockableIndividualNodeUpdatedLinker = nullptr;
74 mConstructedIndiNode = nullptr;
75 mLastConDesIndiReapplication = false;
76 mLastProcessingIndiNode = nullptr;
77 mLastProcessingConDes = nullptr;
78 mIndiProcessNodeLinker = nullptr;
79 mIndiSaturationProcessNodeLinker = nullptr;
80 mIndiSaturationCompletionNodeLinker = nullptr;
81 mIndiSaturationCompletedNodeLinker = nullptr;
82 mIndiSaturationAnalysingNodeLinker = nullptr;
83 mNominalDelayedIndiSaturationProcessNodeLinker = nullptr;
84 mSaturationATMOSTMergingProcessLinker = nullptr;
85 mDisjunctCommonConceptExtractProcessingLinker = nullptr;
86 mRemConSatProcessLinker = nullptr;
87 mRemSatUpdateLinker = nullptr;
88 mRemSatIndiNodeLinker = nullptr;
89 mRemSatIndiSuccLinkDataLinker = nullptr;
90 mRemConSatDes = nullptr;
91 mRemConDes = nullptr;
92 mRemRoleSatProcessLinker = nullptr;
93 mIndiSaturationProcessVector = nullptr;
94 mSatCriticalIndiNodeProcQueue = nullptr;
95 mSatSuccExtIndNodeProcQueue = nullptr;
96 mSatCriticalIndiNodeConTestSet = nullptr;
97 mSatNominalDependentNodeHash = nullptr;
98 mSatInfluencedNominalSet = nullptr;
99 mIndiDepthFirstProcessQueue = nullptr;
100 mUseIndiDepthFirstProcessQueue = nullptr;
101 mPrevIndiDepthFirstProcessQueue = nullptr;
102 mIndiImmProcessQueue = nullptr;
103 mUseIndiImmProcessQueue = nullptr;
104 mPrevIndiImmProcessQueue = nullptr;
105 mDelayNomProcessQueue = nullptr;
106 mUseDelayNomProcessQueue = nullptr;
107 mPrevDelayNomProcessQueue = nullptr;
108 mCachingLossReactivationProcessQueue = nullptr;
109 mUseCachingLossReactivationProcessQueue = nullptr;
110 mPrevCachingLossReactivationProcessQueue = nullptr;
111 mRoleAssertionProcessQueue = nullptr;
112 mUseRoleAssertionProcessQueue = nullptr;
113 mPrevRoleAssertionProcessQueue = nullptr;
114 mBackendSyncRetestProcessQueue = nullptr;
115 mUseBackendSyncRetestProcessQueue = nullptr;
116 mPrevBackendSyncRetestProcessQueue = nullptr;
117 mBackendIndirectCompatibilityExpansionQueue = nullptr;
118 mUseBackendIndirectCompatibilityExpansionQueue = nullptr;
119 mPrevBackendIndirectCompatibilityExpansionQueue = nullptr;
120
121 mBackendIndividualReuseExpansionQueue = nullptr;
122 mUseBackendIndividualReuseExpansionQueue = nullptr;
123 mPrevBackendIndividualReuseExpansionQueue = nullptr;
124 mBackendLateIndividualReuseExpansionQueue = nullptr;
125 mUseBackendLateIndividualReuseExpansionQueue = nullptr;
126 mPrevBackendLateIndividualReuseExpansionQueue = nullptr;
127 mBackendIndividualNeighbourExpansionQueue = nullptr;
128 mUseBackendIndividualNeighbourExpansionQueue = nullptr;
129 mPrevBackendIndividualNeighbourExpansionQueue = nullptr;
130
131 mBackendIndividualLateReuseExpansionActivated = false;
132
133
134 mBackendDirectInfluenceExpansionQueue = nullptr;
135 mUseBackendDirectInfluenceExpansionQueue = nullptr;
136 mPrevBackendDirectInfluenceExpansionQueue = nullptr;
137 mConstructedIndiNodeInitialized = false;
138 mMultipleConstructionIndiNodes = false;
139 mMaximumDeterministicBranchTag = 0;
140 mNextIndividualNodeID = 0;
141 mNextSatResSuccExtIndividualNodeID = -1;
142 mNextPropagationID = 1;
143 mNextVariableID = 1;
144 mNextRepVariableID = 1;
145 mLocExtendedConceptVector = nullptr;
146 mUseExtendedConceptVector = nullptr;
147 mUseGroundingHash = nullptr;
148 mLocGroundingHash = nullptr;
149 mLocVarBindingPathMergingHash = nullptr;
150 mUseVarBindingPathMergingHash = nullptr;
151 mLocRepVarBindPathSetHash = nullptr;
152 mUseRepVarBindPathSetHash = nullptr;
153 mLocRepVarBindPathHash = nullptr;
154 mUseRepVarBindPathHash = nullptr;
155 mLocRepVarBindPathJoiningKeyHash = nullptr;
156 mUseRepVarBindPathJoiningKeyHash = nullptr;
157 mLocRepJoiningHash = nullptr;
158 mUseRepJoiningHash = nullptr;
159 mUseIndiProcessQueue = nullptr;
160 mLocIndiProcessQueue = nullptr;
161 mUseNomCachingLossReactHash = nullptr;
162 mLocNomCachingLossReactHash = nullptr;
163 mUseMarkerIndiNodeHash = nullptr;
164 mLocMarkerIndiNodeHash = nullptr;
165 mUseBackendLoadedAssociationHash = nullptr;
166 mLocBackendLoadedAssociationHash = nullptr;
167 mUseBackendConceptSetLabelProcessingHash = nullptr;
168 mLocBackendConceptSetLabelProcessingHash = nullptr;
169 mUseBackendNeighbourExpansionControllingData = nullptr;
170 mLocBackendNeighbourExpansionControllingData = nullptr;
171
172 mDelayedBackendInitProcQueue = nullptr;
173 mUseDelayedBackendInitProcQueue = nullptr;
174 mPrevDelayedBackendInitProcQueue = nullptr;
175
176 mBackendNeighbourExpansionQueue = nullptr;
177 mUseBackendNeighbourExpansion = nullptr;
178 mPrevBackendNeighbourExpansion = nullptr;
179
180 mIndiDepthProcessingQueue = nullptr;
181 mUseIndiDepthProcessingQueue = nullptr;
182 mPrevIndiDepthProcessingQueue = nullptr;
183
184 mNominalProcessingQueue = nullptr;
185 mUseNominalProcessingQueue = nullptr;
186 mPrevNominalProcessingQueue = nullptr;
187
188 mNominalDeterministicProcessingQueue = nullptr;
189 mUseNominalDeterministicProcessingQueue = nullptr;
190 mPrevNominalDeterministicProcessingQueue = nullptr;
191
192 mIncrementalExansionInitializingProcessingQueue = nullptr;
193 mUseIncrementalExansionInitializingProcessingQueue = nullptr;
194 mPrevIncrementalExansionInitializingProcessingQueue = nullptr;
195
196
197 mIncrementalExansionProcessingQueue = nullptr;
198 mUseIncrementalExansionProcessingQueue = nullptr;
199 mPrevIncrementalExansionProcessingQueue = nullptr;
200
201
202 mIncrementalCompatibilityCheckingQueue = nullptr;
203 mUseIncrementalCompatibilityCheckingQueue = nullptr;
204 mPrevIncrementalCompatibilityCheckingQueue = nullptr;
205
206 mIndiDepthDetExpPreProcessingQueue = nullptr;
207 mUseIndiDepthDetExpPreProcessingQueue = nullptr;
208 mPrevIndiDepthDetExpPreProcessingQueue = nullptr;
209
210 mIndiDepthFirstDetExpPreProcessingQueue = nullptr;
211 mUseIndiDepthFirstDetExpPreProcessingQueue = nullptr;
212 mPrevIndiDepthFirstDetExpPreProcessingQueue = nullptr;
213
214
215 mIndiSignatureBlockingUpdateProcessingQueue = nullptr;
216 mUseIndiSignatureBlockingUpdateProcessingQueue = nullptr;
217 mPrevIndiSignatureBlockingUpdateProcessingQueue = nullptr;
218 mIndiBlockedReactivationProcessingQueue = nullptr;
219 mUseIndiBlockedReactivationProcessingQueue = nullptr;
220 mPrevIndiBlockedReactivationProcessingQueue = nullptr;
221 mVarBindConceptBatchProcessQueue = nullptr;
222 mUseVarBindConceptBatchProcessQueue = nullptr;
223 mPrevVarBindConceptBatchProcessQueue = nullptr;
224 mInsufficientNodeOccured = false;
225 mDelayedNominalProcessingOccured = false;
226 mProblematicEQCandidateNodeOccured = false;
227 mIncrementalExpansionInitialized = false;
228 mIncrementalExpansionCompatibleMerged = false;
229 mIncrementalExpansionCachingMerged = false;
230 mClashedDescriptorLinker = nullptr;
231 mValueSpaceTriggeringProcessingQueue = nullptr;
232 mUseValueSpaceTriggeringProcessingQueue = nullptr;
233 mPrevValueSpaceTriggeringProcessingQueue = nullptr;
234 mDistinctValueSpaceSatisfiabilityCheckingQueue = nullptr;
235 mUseDistinctValueSpaceSatisfiabilityCheckingQueue = nullptr;
236 mPrevDistinctValueSpaceSatisfiabilityCheckingQueue = nullptr;
237
238 mLocalIndiVector = nullptr;
239 mUseIndiVector = nullptr;
240
241 mSeparatedSaturationConAssResolveNode = nullptr;
242 mIncrementalExpID = 0;
243 mMaxIncPrevCompGraphNodeID = 0;
244 mNextIncrementalIndiExpID = 1;
245 mNextRoleAssertionCreationID = 1;
246
247 mReferredIndiTrackVec = nullptr;
248 mIndiDepTrackingRequired = false;
249
250 mBranchingInstruction = nullptr;
251 mRemainingPossibleInstanceIndividualMergingLimit = -1;
252 mPossibleInstanceIndividualMergingSize = 1;
253 mPossibleInstanceIndividualMergedCount = 0;
254 mPossibleInstanceIndividualCurrentMergingCount = 0;
255 mPossibleInstanceIndividualMergingStopped = false;
256
257 mCurrentMergedPossibleInstanceIndividualLinkersLinker = nullptr;
258 mLastMergedPossibleInstanceIndividualLinker = nullptr;
259 mLastBackendCacheIntegratedIndiNodeLinker = nullptr;
260 mBackendCacheIntegratedIndividualNodeCount = 0;
261 mBackendCacheIntegratedSameIndividualNodeCount = 0;
262
263 mBackendCacheUpdateIndividualsInitialized = false;
264 mRepresentativeNeighbourExpansionIndividualNodeLinker = nullptr;
265 }
266
267
268 CProcessingDataBox* CProcessingDataBox::initProcessingDataBox(CConcreteOntology* ontology) {
269 mOntology = ontology;
270 mOntologyTopConcept = mOntology->getTBox()->getTopConcept();
271 mOntologyTopDataRangeConcept = mOntology->getTBox()->getTopDataRangeConcept();
272 mUseExtendedConceptVector = mOntology->getTBox()->getConceptVector(false);
273 mUseIndiVector = mOntology->getABox()->getIndividualVector(false);
274 return this;
275 }
276
277
278 CProcessingDataBox* CProcessingDataBox::setProcessingOntology(CConcreteOntology* ontology) {
279 mOntology = ontology;
280 return this;
281 }
282
283
284 CProcessingDataBox* CProcessingDataBox::initProcessingDataBox(CProcessingDataBox* processingDataBox) {
285 CIndividualProcessNodeVector* prevIndiProcVec = nullptr;
286 mUseIndiProcessQueue = nullptr;
287 mLocIndiProcessQueue = nullptr;
288 mOntology = nullptr;
289 mIndividualNodeCacheTestingLinker = nullptr;
290 mSortedNominalNonDetProcessingNodeLinker = nullptr;
291 mSortedNominalNonDetProcessingNodesSorted = false;
292 mNominalNonDetProcessingCount = 0;
293 mIndividualNodeResolveLinker = nullptr;
294 mBlockableIndividualNodeUpdatedLinker = nullptr;
295 mLastConDesIndiReapplication = false;
296 mIndiProcessNodeLinker = nullptr;
297 mRemSatUpdateLinker = nullptr;
298 mRemSatIndiNodeLinker = nullptr;
299 mRemSatIndiSuccLinkDataLinker = nullptr;
300 mRemConSatDes = nullptr;
301 mRemConDes = nullptr;
302 mRemRoleSatProcessLinker = nullptr;
303
304 mIndiSaturationProcessNodeLinker = nullptr;
305 mIndiSaturationCompletionNodeLinker = nullptr;
306 mIndiSaturationCompletedNodeLinker = nullptr;
307 mIndiSaturationAnalysingNodeLinker = nullptr;
308 mSaturationATMOSTMergingProcessLinker = nullptr;
309 mNominalDelayedIndiSaturationProcessNodeLinker = nullptr;
310 mDisjunctCommonConceptExtractProcessingLinker = nullptr;
311 mRemConSatProcessLinker = nullptr;
312 mIndiSaturationProcessVector = nullptr;
313 mSatCriticalIndiNodeProcQueue = nullptr;
314 mSatSuccExtIndNodeProcQueue = nullptr;
315 mSatCriticalIndiNodeConTestSet = nullptr;
316 mSatNominalDependentNodeHash = nullptr;
317 mSatInfluencedNominalSet = nullptr;
318 mConstructedIndiNodeInitialized = false;
319 mMultipleConstructionIndiNodes = false;
320 mLocExtendedConceptVector = nullptr;
321 mUseExtendedConceptVector = nullptr;
322 mUseGroundingHash = nullptr;
323 mLocGroundingHash = nullptr;
324 mLocVarBindingPathMergingHash = nullptr;
325 mUseVarBindingPathMergingHash = nullptr;
326 mLocRepVarBindPathSetHash = nullptr;
327 mUseRepVarBindPathSetHash = nullptr;
328 mLocRepVarBindPathHash = nullptr;
329 mUseRepVarBindPathHash = nullptr;
330 mLocRepVarBindPathJoiningKeyHash = nullptr;
331 mUseRepVarBindPathJoiningKeyHash = nullptr;
332 mLocRepJoiningHash = nullptr;
333 mUseRepJoiningHash = nullptr;
334 mLocNomCachingLossReactHash = nullptr;
335 mUseNomCachingLossReactHash = nullptr;
336 mUseMarkerIndiNodeHash = nullptr;
337 mLocMarkerIndiNodeHash = nullptr;
338 mUseBackendLoadedAssociationHash = nullptr;
339 mLocBackendLoadedAssociationHash = nullptr;
340 mUseBackendConceptSetLabelProcessingHash = nullptr;
341 mLocBackendConceptSetLabelProcessingHash = nullptr;
342 mUseBackendNeighbourExpansionControllingData = nullptr;
343 mLocBackendNeighbourExpansionControllingData = nullptr;
344 mNextIndividualNodeID = 0;
345 mNextSatResSuccExtIndividualNodeID = -1;
346 mNextPropagationID = 1;
347 mNextVariableID = 1;
348 mNextRepVariableID = 1;
349 mInsufficientNodeOccured = false;
350 mDelayedNominalProcessingOccured = false;
351 mProblematicEQCandidateNodeOccured = false;
352 mIncrementalExpansionInitialized = false;
353 mIncrementalExpansionCompatibleMerged = false;
354 mIncrementalExpansionCachingMerged = false;
355 mSeparatedSaturationConAssResolveNode = nullptr;
356 mBranchingInstruction = nullptr;
357 mRemainingPossibleInstanceIndividualMergingLimit = -1;
358 mPossibleInstanceIndividualMergingStopped = false;
359 mPossibleInstanceIndividualMergingSize = 1;
360 mPossibleInstanceIndividualMergedCount = 0;
361 mPossibleInstanceIndividualCurrentMergingCount = 0;
362 mLastMergedPossibleInstanceIndividualLinker = nullptr;
363 mCurrentMergedPossibleInstanceIndividualLinkersLinker = nullptr;
364 mLastBackendCacheIntegratedIndiNodeLinker = nullptr;
365 mBackendCacheIntegratedIndividualNodeCount = 0;
366 mBackendCacheIntegratedSameIndividualNodeCount = 0;
367 mLocalIndiVector = nullptr;
368 mBackendCacheUpdateIndividualsInitialized = false;
369 mRepresentativeNeighbourExpansionIndividualNodeLinker = nullptr;
370 if (processingDataBox) {
371 mPossibleInstanceIndividualMergingStopped = processingDataBox->mPossibleInstanceIndividualMergingStopped;
372 mPossibleInstanceIndividualMergingSize = processingDataBox->mPossibleInstanceIndividualMergingSize;
373 mPossibleInstanceIndividualMergedCount = processingDataBox->mPossibleInstanceIndividualMergedCount;
374 mPossibleInstanceIndividualCurrentMergingCount = processingDataBox->mPossibleInstanceIndividualCurrentMergingCount;
375 mRemainingPossibleInstanceIndividualMergingLimit = processingDataBox->mRemainingPossibleInstanceIndividualMergingLimit;
376 mLastMergedPossibleInstanceIndividualLinker = processingDataBox->mLastMergedPossibleInstanceIndividualLinker;
377 mCurrentMergedPossibleInstanceIndividualLinkersLinker = processingDataBox->mCurrentMergedPossibleInstanceIndividualLinkersLinker;
378 mLastBackendCacheIntegratedIndiNodeLinker = processingDataBox->mLastBackendCacheIntegratedIndiNodeLinker;
379 mBackendCacheIntegratedIndividualNodeCount = processingDataBox->mBackendCacheIntegratedIndividualNodeCount;
380 mBackendCacheIntegratedSameIndividualNodeCount = processingDataBox->mBackendCacheIntegratedSameIndividualNodeCount;
381 mBranchingInstruction = processingDataBox->mBranchingInstruction;
382 mUseIndiProcessQueue = processingDataBox->mUseIndiProcessQueue;
383 prevIndiProcVec = processingDataBox->mIndiProcessVector;
384 mOntology = processingDataBox->mOntology;
385 mPrevIndiDepthProcessingQueue = processingDataBox->mUseIndiDepthProcessingQueue;
386 mUseIndiDepthProcessingQueue = mPrevIndiDepthProcessingQueue;
387 mPrevNominalProcessingQueue = processingDataBox->mUseNominalProcessingQueue;
388 mUseNominalProcessingQueue = mPrevNominalProcessingQueue;
389 mPrevIncrementalExansionInitializingProcessingQueue = processingDataBox->mUseIncrementalExansionInitializingProcessingQueue;
390 mUseIncrementalExansionInitializingProcessingQueue = mPrevIncrementalExansionInitializingProcessingQueue;
391 mPrevIncrementalCompatibilityCheckingQueue = processingDataBox->mUseIncrementalCompatibilityCheckingQueue;
392 mUseIncrementalCompatibilityCheckingQueue = mPrevIncrementalCompatibilityCheckingQueue;
393 mPrevIndiDepthDetExpPreProcessingQueue = processingDataBox->mUseIndiDepthDetExpPreProcessingQueue;
394 mUseIndiDepthDetExpPreProcessingQueue = mPrevIndiDepthDetExpPreProcessingQueue;
395 mPrevIndiDepthFirstDetExpPreProcessingQueue = processingDataBox->mUseIndiDepthFirstDetExpPreProcessingQueue;
396 mUseIndiDepthFirstDetExpPreProcessingQueue = mPrevIndiDepthFirstDetExpPreProcessingQueue;
397 mPrevIndiBlockedReactivationProcessingQueue = processingDataBox->mUseIndiBlockedReactivationProcessingQueue;
398 mUseIndiBlockedReactivationProcessingQueue = mPrevIndiBlockedReactivationProcessingQueue;
399 mPrevVarBindConceptBatchProcessQueue = processingDataBox->mUseVarBindConceptBatchProcessQueue;
400 mUseVarBindConceptBatchProcessQueue = mPrevVarBindConceptBatchProcessQueue;
401 mPrevIndiSignatureBlockingUpdateProcessingQueue = processingDataBox->mUseIndiSignatureBlockingUpdateProcessingQueue;
402 mUseIndiSignatureBlockingUpdateProcessingQueue = mPrevIndiSignatureBlockingUpdateProcessingQueue;
403 mPrevValueSpaceTriggeringProcessingQueue = processingDataBox->mUseValueSpaceTriggeringProcessingQueue;
404 mUseValueSpaceTriggeringProcessingQueue = mPrevValueSpaceTriggeringProcessingQueue;
405 mPrevDistinctValueSpaceSatisfiabilityCheckingQueue = processingDataBox->mUseDistinctValueSpaceSatisfiabilityCheckingQueue;
406 mUseDistinctValueSpaceSatisfiabilityCheckingQueue = mPrevDistinctValueSpaceSatisfiabilityCheckingQueue;
407 mPrevSignatureBlockingCandidateHash = processingDataBox->mUseSignatureBlockingCandidateHash;
408 mUseSignatureBlockingCandidateHash = mPrevSignatureBlockingCandidateHash;
409
410 mPrevSignatureNominalDelayingCandidateHash = processingDataBox->mUseSignatureNominalDelayingCandidateHash;
411 mUseSignatureNominalDelayingCandidateHash = mPrevSignatureNominalDelayingCandidateHash;
412
413 mPrevBlockingIndiNodeCandidateHash = processingDataBox->mUseBlockingIndiNodeCandidateHash;
414 mUseBlockingIndiNodeCandidateHash = mPrevBlockingIndiNodeCandidateHash;
415 mPrevBlockingIndiNodeLinkedCandidateHash = processingDataBox->mUseBlockingIndiNodeLinkedCandidateHash;
416 mUseBlockingIndiNodeLinkedCandidateHash = mPrevBlockingIndiNodeLinkedCandidateHash;
417 mPrevSignatureBlockingReviewSet = processingDataBox->mUseSignatureBlockingReviewSet;
418 mUseSignatureBlockingReviewSet = mPrevSignatureBlockingReviewSet;
419 mPrevEarlyIndiReactProQueue = processingDataBox->mUseEarlyIndiReactProQueue;
420 mUseEarlyIndiReactProQueue = mPrevEarlyIndiReactProQueue;
421 mPrevLateIndiReactProQueue = processingDataBox->mUseLateIndiReactProQueue;
422 mUseLateIndiReactProQueue = mPrevLateIndiReactProQueue;
423 mPrevReusingReviewSet = processingDataBox->mUseReusingReviewSet;
424 mUseReusingReviewSet = mPrevReusingReviewSet;
425 mPrevNodeSwitchHistory = processingDataBox->mUseNodeSwitchHistory;
426 mUseNodeSwitchHistory = mPrevNodeSwitchHistory;
427 mPrevIndiDepthFirstProcessQueue = processingDataBox->mUseIndiDepthFirstProcessQueue;
428 mUseIndiDepthFirstProcessQueue = mPrevIndiDepthFirstProcessQueue;
429 mPrevIndiImmProcessQueue = processingDataBox->mUseIndiImmProcessQueue;
430 mUseIndiImmProcessQueue = mPrevIndiImmProcessQueue;
431 mPrevDelayNomProcessQueue = processingDataBox->mUseDelayNomProcessQueue;
432 mUseDelayNomProcessQueue = mPrevDelayNomProcessQueue;
433 mPrevCachingLossReactivationProcessQueue = processingDataBox->mUseCachingLossReactivationProcessQueue;
434 mUseCachingLossReactivationProcessQueue = mPrevCachingLossReactivationProcessQueue;
435
436 mPrevDelayedBackendInitProcQueue = processingDataBox->mUseDelayedBackendInitProcQueue;
437 mUseDelayedBackendInitProcQueue = mPrevDelayedBackendInitProcQueue;
438
439 mPrevBackendNeighbourExpansion = processingDataBox->mUseBackendNeighbourExpansion;
440 mUseBackendNeighbourExpansion = mPrevBackendNeighbourExpansion;
441
442 mPrevRoleAssertionProcessQueue = processingDataBox->mUseRoleAssertionProcessQueue;
443 mUseRoleAssertionProcessQueue = mPrevRoleAssertionProcessQueue;
444 mPrevBackendSyncRetestProcessQueue = processingDataBox->mUseBackendSyncRetestProcessQueue;
445 mUseBackendSyncRetestProcessQueue = mPrevBackendSyncRetestProcessQueue;
446 mPrevBackendIndirectCompatibilityExpansionQueue = processingDataBox->mUseBackendIndirectCompatibilityExpansionQueue;
447 mUseBackendIndirectCompatibilityExpansionQueue = mPrevBackendIndirectCompatibilityExpansionQueue;
448 mPrevBackendDirectInfluenceExpansionQueue = processingDataBox->mUseBackendDirectInfluenceExpansionQueue;
449 mUseBackendDirectInfluenceExpansionQueue = mPrevBackendDirectInfluenceExpansionQueue;
450
451 mPrevBackendIndividualReuseExpansionQueue = processingDataBox->mUseBackendIndividualReuseExpansionQueue;
452 mUseBackendIndividualReuseExpansionQueue = mPrevBackendIndividualReuseExpansionQueue;
453 mBackendIndividualLateReuseExpansionActivated = processingDataBox->mBackendIndividualLateReuseExpansionActivated;
454 mPrevBackendLateIndividualReuseExpansionQueue = processingDataBox->mUseBackendLateIndividualReuseExpansionQueue;
455 mUseBackendLateIndividualReuseExpansionQueue = mPrevBackendLateIndividualReuseExpansionQueue;
456 mPrevBackendIndividualNeighbourExpansionQueue = processingDataBox->mUseBackendIndividualNeighbourExpansionQueue;
457 mUseBackendIndividualNeighbourExpansionQueue = mPrevBackendIndividualNeighbourExpansionQueue;
458
459 mPrevBranchingTree = processingDataBox->mUseBranchingTree;
460 mUseBranchingTree = mPrevBranchingTree;
461 mOntologyTopConcept = processingDataBox->mOntologyTopConcept;
462 mOntologyTopDataRangeConcept = processingDataBox->mOntologyTopDataRangeConcept;
463 mIndividualNodeCacheTestingLinker = processingDataBox->mIndividualNodeCacheTestingLinker;
464 mSortedNominalNonDetProcessingNodeLinker = processingDataBox->mSortedNominalNonDetProcessingNodeLinker;
465 mSortedNominalNonDetProcessingNodesSorted = processingDataBox->mSortedNominalNonDetProcessingNodesSorted;
466 mNominalNonDetProcessingCount = processingDataBox->mNominalNonDetProcessingCount;
467 mIndividualNodeResolveLinker = processingDataBox->mIndividualNodeResolveLinker;
468 mBlockableIndividualNodeUpdatedLinker = processingDataBox->mBlockableIndividualNodeUpdatedLinker;
469 mConstructedIndiNode = processingDataBox->mConstructedIndiNode;
470 mLastProcessingIndiNode = processingDataBox->mLastProcessingIndiNode;
471 mLastProcessingConDes = processingDataBox->mLastProcessingConDes;
472 mIndiProcessNodeLinker = processingDataBox->mIndiProcessNodeLinker;
473 mMultipleConstructionIndiNodes = processingDataBox->mMultipleConstructionIndiNodes;
474 mConstructedIndiNodeInitialized = processingDataBox->mConstructedIndiNodeInitialized;
475 mMaximumDeterministicBranchTag = processingDataBox->mMaximumDeterministicBranchTag;
476 mNextPropagationID = processingDataBox->mNextPropagationID;
477 mNextIndividualNodeID = processingDataBox->mNextIndividualNodeID;
478 mNextSatResSuccExtIndividualNodeID = processingDataBox->mNextSatResSuccExtIndividualNodeID;
479 mNextVariableID = processingDataBox->mNextVariableID;
480 mNextRepVariableID = processingDataBox->mNextRepVariableID;
481 mUseExtendedConceptVector = processingDataBox->mUseExtendedConceptVector;
482 mUseGroundingHash = processingDataBox->mUseGroundingHash;
483 mUseVarBindingPathMergingHash = processingDataBox->mUseVarBindingPathMergingHash;
484 mUseRepVarBindPathSetHash = processingDataBox->mUseRepVarBindPathSetHash;
485 mUseRepVarBindPathHash = processingDataBox->mUseRepVarBindPathHash;
486 mUseRepVarBindPathJoiningKeyHash = processingDataBox->mUseRepVarBindPathJoiningKeyHash;
487 mUseRepJoiningHash = processingDataBox->mUseRepJoiningHash;
488 mInsufficientNodeOccured = processingDataBox->mInsufficientNodeOccured;
489 mDelayedNominalProcessingOccured = processingDataBox->mDelayedNominalProcessingOccured;
490 mProblematicEQCandidateNodeOccured = processingDataBox->mProblematicEQCandidateNodeOccured;
491 mUseNomCachingLossReactHash = processingDataBox->mUseNomCachingLossReactHash;
492 mUseMarkerIndiNodeHash = processingDataBox->mUseMarkerIndiNodeHash;
493 mUseBackendConceptSetLabelProcessingHash = processingDataBox->mUseBackendConceptSetLabelProcessingHash;
494 mUseBackendLoadedAssociationHash = processingDataBox->mUseBackendLoadedAssociationHash;
495 mUseBackendNeighbourExpansionControllingData = processingDataBox->mUseBackendNeighbourExpansionControllingData;
496 mIncrementalExpansionInitialized = processingDataBox->mIncrementalExpansionInitialized;
497 mNextIncrementalIndiExpID = processingDataBox->mNextIncrementalIndiExpID;
498 mNextRoleAssertionCreationID = processingDataBox->mNextRoleAssertionCreationID;
499 mIncrementalExpID = processingDataBox->mIncrementalExpID;
500 mMaxIncPrevCompGraphNodeID = processingDataBox->mMaxIncPrevCompGraphNodeID;
501 mIncrementalExpansionCompatibleMerged = processingDataBox->mIncrementalExpansionCompatibleMerged;
502 mIncrementalExpansionCachingMerged = processingDataBox->mIncrementalExpansionCachingMerged;
503 mReferredIndiTrackVec = processingDataBox->mReferredIndiTrackVec;
504 mIndiDepTrackingRequired = processingDataBox->mIndiDepTrackingRequired;
505
506
507 mIndiSaturationProcessNodeLinker = processingDataBox->mIndiSaturationProcessNodeLinker;
508 mIndiSaturationCompletionNodeLinker = processingDataBox->mIndiSaturationCompletionNodeLinker;
509 mIndiSaturationCompletedNodeLinker = processingDataBox->mIndiSaturationCompletedNodeLinker;
510 mIndiSaturationAnalysingNodeLinker = processingDataBox->mIndiSaturationAnalysingNodeLinker;
511 mDisjunctCommonConceptExtractProcessingLinker = processingDataBox->mDisjunctCommonConceptExtractProcessingLinker;
512 mNominalDelayedIndiSaturationProcessNodeLinker = processingDataBox->mNominalDelayedIndiSaturationProcessNodeLinker;
513 mSaturationATMOSTMergingProcessLinker = processingDataBox->mSaturationATMOSTMergingProcessLinker;
514 mUseIndiVector = processingDataBox->mUseIndiVector;
515
516 mBackendCacheUpdateIndividualsInitialized = processingDataBox->mBackendCacheUpdateIndividualsInitialized;
517 mRepresentativeNeighbourExpansionIndividualNodeLinker = processingDataBox->mRepresentativeNeighbourExpansionIndividualNodeLinker;
518
519 if (processingDataBox->mIndiSaturationProcessVector) {
520 getIndividualSaturationProcessNodeVector(true)->referenceVector(processingDataBox->mIndiSaturationProcessVector);
521 }
522 if (processingDataBox->mSatInfluencedNominalSet) {
523 getSaturationInfluencedNominalSet(true)->initInfluencedNominalSet(processingDataBox->mSatInfluencedNominalSet);
524 }
525 if (processingDataBox->mSatNominalDependentNodeHash) {
526 getSaturationNominalDependentNodeHash(true)->initNominalDependentNodeHash(processingDataBox->mSatNominalDependentNodeHash);
527 }
528 if (processingDataBox->mSatCriticalIndiNodeConTestSet) {
529 getSaturationCriticalIndividualNodeConceptTestSet(true)->initIndividualNodeConceptTestSet(processingDataBox->mSatCriticalIndiNodeConTestSet);
530 }
531 if (processingDataBox->mSatSuccExtIndNodeProcQueue) {
532 getSaturationSucessorExtensionIndividualNodeProcessingQueue(true)->initProcessingQueue(processingDataBox->mSatSuccExtIndNodeProcQueue);
533 }
534 if (processingDataBox->mSatCriticalIndiNodeProcQueue) {
535 getSaturationCriticalIndividualNodeProcessingQueue(true)->initProcessingQueue(processingDataBox->mSatCriticalIndiNodeProcQueue);
536 }
537
538 }
539 mIndiProcessVector->referenceVector(prevIndiProcVec);
540 return this;
541 }
542
543 bool CProcessingDataBox::hasClashedDescriptorLinker() {
544 return mClashedDescriptorLinker != nullptr;
545 }
546
547 CClashedDependencyDescriptor* CProcessingDataBox::getClashedDescriptorLinker() {
548 return mClashedDescriptorLinker;
549 }
550
551 CProcessingDataBox* CProcessingDataBox::setClashedDescriptorLinker(CClashedDependencyDescriptor* clashDesLinker) {
552 mClashedDescriptorLinker = clashDesLinker;
553 return this;
554 }
555
556 CProcessingDataBox* CProcessingDataBox::clearIndividualProcessingQueues() {
557 clearRoleAssertionProcessingQueue();
558 clearDelayingNominalProcessingQueue();
559 clearIndividualDepthFirstProcessingQueue();
560 clearIndividualImmediatelyProcessingQueue();
561 clearVariableBindingConceptBatchProcessingQueue();
562 clearIndividualDepthProcessingQueue();
563 clearNominalDeterministicProcessingQueue();
564 clearNominalProcessingQueue();
565 clearIndividualDepthDeterministicExpansionPreprocessingQueue();
566 clearIndividualDepthFirstDeterministicExpansionProcessingQueue();
567 clearBlockingUpdateReviewProcessingQueue();
568 clearBlockedReactivationProcessingQueue();
569 clearEarlyIndividualReactivationProcessingQueue();
570 clearReusingReviewData();
571 clearBlockedResolveIndividualNodes();
572 clearSortedNominalNonDeterministicProcessingNodeLinker();
573 clearValueSpaceTriggeringProcessingQueue();
574 clearDistinctValueSpaceSatisfiabilityCheckingQueue();
575 clearIncrementalExpansionInitializingProcessingQueue();
576 clearIncrementalCompatibilityCheckingQueue();
577 clearIncrementalExpansionIProcessingQueue();
578 clearBackendCacheSynchronizationProcessingQueue();
579 clearBackendDirectInfluenceExpansionQueue();
580 clearBackendIndirectCompatibilityExpansionQueue();
581 clearDelayedBackendConceptSetLabelProcessingInitializationQueue();
582 clearBackendNeighbourExpansionQueue();
583 clearBackendIndividualNeighbourExpansionQueue();
584 clearBackendIndividualReuseExpansionQueue();
585 clearBackendLateIndividualNeighbourExpansionQueue();
586 return this;
587 }
588
589
590 CIndividualVector* CProcessingDataBox::getIndividualVector(bool localize) {
591 if (!mLocalIndiVector && localize) {
592 mLocalIndiVector = CObjectParameterizingAllocator<CIndividualVector, CContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext), mProcessContext);
593 mLocalIndiVector->referenceVector(mUseIndiVector);
594 mUseIndiVector = mLocalIndiVector;
595 }
596 return mUseIndiVector;
597 }
598
599
600 CConceptVector* CProcessingDataBox::getExtendedConceptVector(bool forceLocalisation) {
601 if (forceLocalisation && !mLocExtendedConceptVector) {
602 mLocExtendedConceptVector = CObjectParameterizingAllocator<CConceptVector,CContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
603 mLocExtendedConceptVector->referenceVector(mUseExtendedConceptVector);
604 mUseExtendedConceptVector = mLocExtendedConceptVector;
605 }
606 return mUseExtendedConceptVector;
607 }
608
609
610 CConceptNominalSchemaGroundingHash* CProcessingDataBox::getConceptNominalSchemaGroundingHash(bool forceLocalisation) {
611 if (forceLocalisation && !mLocGroundingHash) {
612 mLocGroundingHash = CObjectParameterizingAllocator<CConceptNominalSchemaGroundingHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
613 mLocGroundingHash->initConceptNominalSchemaGroundingHash(mUseGroundingHash);
614 mUseGroundingHash = mLocGroundingHash;
615 }
616 return mUseGroundingHash;
617 }
618
619
620
621 CVariableBindingPathMergingHash* CProcessingDataBox::getVariableBindingPathMergingHash(bool forceLocalisation) {
622 if (forceLocalisation && !mLocVarBindingPathMergingHash) {
623 mLocVarBindingPathMergingHash = CObjectParameterizingAllocator<CVariableBindingPathMergingHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
624 mLocVarBindingPathMergingHash->initVariableBindingPathMergingHash(mUseVarBindingPathMergingHash);
625 mUseVarBindingPathMergingHash = mLocVarBindingPathMergingHash;
626 }
627 return mUseVarBindingPathMergingHash;
628 }
629
630
631 CRepresentativeVariableBindingPathSetHash* CProcessingDataBox::getRepresentativeVariableBindingPathSetHash(bool forceLocalisation) {
632 if (forceLocalisation && !mLocRepVarBindPathSetHash) {
633 mLocRepVarBindPathSetHash = CObjectParameterizingAllocator<CRepresentativeVariableBindingPathSetHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
634 mLocRepVarBindPathSetHash->initRepresentativeVariableBindingPathSetHash(mUseRepVarBindPathSetHash);
635 mUseRepVarBindPathSetHash = mLocRepVarBindPathSetHash;
636 }
637 return mUseRepVarBindPathSetHash;
638 }
639
640 CRepresentativeVariableBindingPathHash* CProcessingDataBox::getRepresentativeVariableBindingPathHash(bool forceLocalisation) {
641 if (forceLocalisation && !mLocRepVarBindPathHash) {
642 mLocRepVarBindPathHash = CObjectParameterizingAllocator<CRepresentativeVariableBindingPathHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
643 mLocRepVarBindPathHash->initRepresentativeVariableBindingPathHash(mUseRepVarBindPathHash);
644 mUseRepVarBindPathHash = mLocRepVarBindPathHash;
645 }
646 return mUseRepVarBindPathHash;
647 }
648
649
650
651 CRepresentativeVariableBindingPathJoiningKeyHash* CProcessingDataBox::getRepresentativeVariableBindingPathJoiningKeyHash(bool forceLocalisation) {
652 if (forceLocalisation && !mLocRepVarBindPathJoiningKeyHash) {
653 mLocRepVarBindPathJoiningKeyHash = CObjectParameterizingAllocator<CRepresentativeVariableBindingPathJoiningKeyHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
654 mLocRepVarBindPathJoiningKeyHash->initRepresentativeVariableBindingPathJoiningKeyHash(mUseRepVarBindPathJoiningKeyHash);
655 mUseRepVarBindPathJoiningKeyHash = mLocRepVarBindPathJoiningKeyHash;
656 }
657 return mUseRepVarBindPathJoiningKeyHash;
658 }
659
660 CRepresentativeJoiningHash* CProcessingDataBox::getRepresentativeJoiningHash(bool forceLocalisation) {
661 if (forceLocalisation && !mLocRepJoiningHash) {
662 mLocRepJoiningHash = CObjectParameterizingAllocator<CRepresentativeJoiningHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
663 mLocRepJoiningHash->initRepresentativeJoiningHash(mUseRepJoiningHash);
664 mUseRepJoiningHash = mLocRepJoiningHash;
665 }
666 return mUseRepJoiningHash;
667 }
668
669
670 CNominalCachingLossReactivationHash* CProcessingDataBox::getNominalCachingLossReactivationHash(bool createOrForceLocalisation) {
671 if (createOrForceLocalisation && !mLocNomCachingLossReactHash) {
672 mLocNomCachingLossReactHash = CObjectParameterizingAllocator<CNominalCachingLossReactivationHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
673 mLocNomCachingLossReactHash->initNominalDependentNodeHash(mUseNomCachingLossReactHash);
674 mUseNomCachingLossReactHash = mLocNomCachingLossReactHash;
675 }
676 return mUseNomCachingLossReactHash;
677 }
678
679
680 CMarkerIndividualNodeHash* CProcessingDataBox::getMarkerIndividualNodeHash(bool createOrForceLocalisation) {
681 if (createOrForceLocalisation && !mLocMarkerIndiNodeHash) {
682 mLocMarkerIndiNodeHash = CObjectParameterizingAllocator<CMarkerIndividualNodeHash,CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext),mProcessContext);
683 mLocMarkerIndiNodeHash->initMarkerIndividualNodeHash(mUseMarkerIndiNodeHash);
684 mUseMarkerIndiNodeHash = mLocMarkerIndiNodeHash;
685 }
686 return mUseMarkerIndiNodeHash;
687 }
688
689
690 cint64 CProcessingDataBox::getNextSaturationResolvedSuccessorExtensionIndividualNodeID(bool incremetNextID) {
691 if (mNextSatResSuccExtIndividualNodeID == -1) {
692 mNextSatResSuccExtIndividualNodeID = mIndiSaturationProcessVector->getItemCount();
693 mNextSatResSuccExtIndividualNodeID = qMax(mNextSatResSuccExtIndividualNodeID, mOntology->getABox()->getIndividualCount());
694 COntologyTriplesAssertionsAccessor* triplesAccessor = mOntology->getOntologyTriplesData()->getTripleAssertionAccessor();
695 if (triplesAccessor) {
696 mNextSatResSuccExtIndividualNodeID = qMax(mNextSatResSuccExtIndividualNodeID, mOntology->getOntologyTriplesData()->getTripleAssertionAccessor()->getMaxIndexedIndividualId());
697 }
698 }
699 cint64 nextPropID = mNextSatResSuccExtIndividualNodeID;
700 if (incremetNextID) {
701 ++mNextSatResSuccExtIndividualNodeID;
702 }
703 return nextPropID;
704 }
705
706 cint64 CProcessingDataBox::getNextIndividualNodeID(bool incremetNextID) {
707 cint64 nextPropID = mNextIndividualNodeID;
708 if (incremetNextID) {
709 ++mNextIndividualNodeID;
710 }
711 return nextPropID;
712 }
713
714 CProcessingDataBox* CProcessingDataBox::setFirstPossibleIndividualNodeID(cint64 indiID) {
715 mNextIndividualNodeID = indiID;
716 return this;
717 }
718
719
720 cint64 CProcessingDataBox::getNextBindingPropagationID(bool incremetNextID) {
721 cint64 nextPropID = mNextPropagationID;
722 if (incremetNextID) {
723 ++mNextPropagationID;
724 }
725 return nextPropID;
726 }
727
728 cint64 CProcessingDataBox::getNextVariableBindingPathID(bool incremetNextID) {
729 cint64 nextPropID = mNextVariableID;
730 if (incremetNextID) {
731 ++mNextVariableID;
732 }
733 return nextPropID;
734 }
735
736 cint64 CProcessingDataBox::getNextRepresentativeVariableBindingPathID(bool incremetNextID) {
737 cint64 nextPropID = mNextRepVariableID;
738 if (incremetNextID) {
739 ++mNextRepVariableID;
740 }
741 return nextPropID;
742 }
743
744 CIndividualProcessingQueue* CProcessingDataBox::getIndividualProcessingQueue(bool create) {
745 if (!mLocIndiProcessQueue) {
746 mLocIndiProcessQueue = CObjectParameterizingAllocator< CIndividualProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
747 mLocIndiProcessQueue->initProcessingQueue(mUseIndiProcessQueue);
748 mUseIndiProcessQueue = mLocIndiProcessQueue;
749 }
750 return mUseIndiProcessQueue;
751 }
752
753
754 CProcessingDataBox* CProcessingDataBox::clearIndividualProcessingQueue() {
755 mUseIndiProcessQueue = nullptr;
756 mLocIndiProcessQueue = nullptr;
757 return this;
758 }
759
760
761 CIndividualProcessNodeVector* CProcessingDataBox::getIndividualProcessNodeVector() {
762 return mIndiProcessVector;
763 }
764
765 CProcessingDataBox* CProcessingDataBox::setIndividualProcessNodeVector(CIndividualProcessNodeVector* indiNodeVec) {
766 mIndiProcessVector = indiNodeVec;
767 return this;
768 }
769
770
771 CConcept* CProcessingDataBox::getOntologyTopConcept() {
772 return mOntologyTopConcept;
773 }
774
775 CConcept* CProcessingDataBox::getOntologyTopDataRangeConcept() {
776 return mOntologyTopDataRangeConcept;
777 }
778
779 CConcreteOntology* CProcessingDataBox::getOntology() {
780 return mOntology;
781 }
782
783
784 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getIndividualDepthFirstProcessingQueue(bool create) {
785 if (!mIndiDepthFirstProcessQueue && create) {
786 mIndiDepthFirstProcessQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
787 mIndiDepthFirstProcessQueue->initProcessingQueue(mPrevIndiDepthFirstProcessQueue);
788 mUseIndiDepthFirstProcessQueue = mIndiDepthFirstProcessQueue;
789 }
790 return mUseIndiDepthFirstProcessQueue;
791 }
792
793
794 CProcessingDataBox* CProcessingDataBox::clearIndividualDepthFirstProcessingQueue() {
795 mIndiDepthFirstProcessQueue = nullptr;
796 mUseIndiDepthFirstProcessQueue = nullptr;
797 mPrevIndiDepthFirstProcessQueue = nullptr;
798 return this;
799 }
800
801
802
803 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getIndividualImmediatelyProcessingQueue(bool create) {
804 if (!mIndiImmProcessQueue && create) {
805 mIndiImmProcessQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
806 mIndiImmProcessQueue->initProcessingQueue(mPrevIndiImmProcessQueue);
807 mUseIndiImmProcessQueue = mIndiImmProcessQueue;
808 }
809 return mUseIndiImmProcessQueue;
810 }
811
812
813 CProcessingDataBox* CProcessingDataBox::clearIndividualImmediatelyProcessingQueue() {
814 mIndiImmProcessQueue = nullptr;
815 mUseIndiImmProcessQueue = nullptr;
816 mPrevIndiImmProcessQueue = nullptr;
817 return this;
818 }
819
820
821
822 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getRoleAssertionExpansionProcessingQueue(bool create) {
823 if (!mRoleAssertionProcessQueue && create) {
824 mRoleAssertionProcessQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
825 mRoleAssertionProcessQueue->initProcessingQueue(mPrevRoleAssertionProcessQueue);
826 mUseRoleAssertionProcessQueue = mRoleAssertionProcessQueue;
827 }
828 return mUseRoleAssertionProcessQueue;
829 }
830
831
832 CProcessingDataBox* CProcessingDataBox::clearRoleAssertionProcessingQueue() {
833 mRoleAssertionProcessQueue = nullptr;
834 mUseRoleAssertionProcessQueue = nullptr;
835 mPrevRoleAssertionProcessQueue = nullptr;
836 return this;
837 }
838
839
840
841
842 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getBackendCacheSynchronizationProcessingQueue(bool create) {
843 if (!mBackendSyncRetestProcessQueue && create) {
844 mBackendSyncRetestProcessQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
845 mBackendSyncRetestProcessQueue->initProcessingQueue(mPrevBackendSyncRetestProcessQueue);
846 mUseBackendSyncRetestProcessQueue = mBackendSyncRetestProcessQueue;
847 }
848 return mUseBackendSyncRetestProcessQueue;
849 }
850
851
852 CProcessingDataBox* CProcessingDataBox::clearBackendCacheSynchronizationProcessingQueue() {
853 mBackendSyncRetestProcessQueue = nullptr;
854 mUseBackendSyncRetestProcessQueue = nullptr;
855 mPrevBackendSyncRetestProcessQueue = nullptr;
856 return this;
857 }
858
859
860
861
862 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getBackendDirectInfluenceExpansionQueue(bool create) {
863 if (!mBackendDirectInfluenceExpansionQueue && create) {
864 mBackendDirectInfluenceExpansionQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
865 mBackendDirectInfluenceExpansionQueue->initProcessingQueue(mPrevBackendDirectInfluenceExpansionQueue);
866 mUseBackendDirectInfluenceExpansionQueue = mBackendDirectInfluenceExpansionQueue;
867 }
868 return mUseBackendDirectInfluenceExpansionQueue;
869 }
870
871
872 CProcessingDataBox* CProcessingDataBox::clearBackendDirectInfluenceExpansionQueue() {
873 mBackendDirectInfluenceExpansionQueue = nullptr;
874 mUseBackendDirectInfluenceExpansionQueue = nullptr;
875 mPrevBackendDirectInfluenceExpansionQueue = nullptr;
876 return this;
877 }
878
879
880
881 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getBackendIndirectCompatibilityExpansionQueue(bool create) {
882 if (!mBackendIndirectCompatibilityExpansionQueue && create) {
883 mBackendIndirectCompatibilityExpansionQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
884 mBackendIndirectCompatibilityExpansionQueue->initProcessingQueue(mPrevBackendIndirectCompatibilityExpansionQueue);
885 mUseBackendIndirectCompatibilityExpansionQueue = mBackendIndirectCompatibilityExpansionQueue;
886 }
887 return mUseBackendIndirectCompatibilityExpansionQueue;
888 }
889
890
891 CProcessingDataBox* CProcessingDataBox::clearBackendIndirectCompatibilityExpansionQueue() {
892 mBackendIndirectCompatibilityExpansionQueue = nullptr;
893 mUseBackendIndirectCompatibilityExpansionQueue = nullptr;
894 mPrevBackendIndirectCompatibilityExpansionQueue = nullptr;
895 return this;
896 }
897
898
899
900
901
902
903
904
905 bool CProcessingDataBox::isBackendIndividualLateReuseExpansionActivated() {
906 return mBackendIndividualLateReuseExpansionActivated;
907 }
908
909 CProcessingDataBox* CProcessingDataBox::setBackendIndividualLateReuseExpansionActivated(bool activated) {
910 mBackendIndividualLateReuseExpansionActivated = activated;
911 return this;
912 }
913
914
915
916 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getBackendIndividualReuseExpansionQueue(bool create) {
917 if (!mBackendLateIndividualReuseExpansionQueue && create) {
918 mBackendLateIndividualReuseExpansionQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
919 mBackendLateIndividualReuseExpansionQueue->initProcessingQueue(mPrevBackendLateIndividualReuseExpansionQueue);
920 mUseBackendLateIndividualReuseExpansionQueue = mBackendLateIndividualReuseExpansionQueue;
921 }
922 return mUseBackendLateIndividualReuseExpansionQueue;
923 }
924
925
926 CProcessingDataBox* CProcessingDataBox::clearBackendIndividualReuseExpansionQueue() {
927 mBackendLateIndividualReuseExpansionQueue = nullptr;
928 mUseBackendLateIndividualReuseExpansionQueue = nullptr;
929 mPrevBackendLateIndividualReuseExpansionQueue = nullptr;
930 return this;
931 }
932
933
934
935
936
937
938
939
940 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getBackendLateIndividualNeighbourExpansionQueue(bool create) {
941 if (!mBackendIndividualReuseExpansionQueue && create) {
942 mBackendIndividualReuseExpansionQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
943 mBackendIndividualReuseExpansionQueue->initProcessingQueue(mPrevBackendIndividualReuseExpansionQueue);
944 mUseBackendIndividualReuseExpansionQueue = mBackendIndividualReuseExpansionQueue;
945 }
946 return mUseBackendIndividualReuseExpansionQueue;
947 }
948
949
950 CProcessingDataBox* CProcessingDataBox::clearBackendLateIndividualNeighbourExpansionQueue() {
951 mBackendIndividualReuseExpansionQueue = nullptr;
952 mUseBackendIndividualReuseExpansionQueue = nullptr;
953 mPrevBackendIndividualReuseExpansionQueue = nullptr;
954 return this;
955 }
956
957
958
959
960
961
962
963
964
965
966
967
968
969 CIndividualLinkerRotationProcessingQueue* CProcessingDataBox::getBackendIndividualNeighbourExpansionQueue(bool create) {
970 if (!mBackendIndividualNeighbourExpansionQueue && create) {
971 mBackendIndividualNeighbourExpansionQueue = CObjectParameterizingAllocator< CIndividualLinkerRotationProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
972 mBackendIndividualNeighbourExpansionQueue->initProcessingQueue(mPrevBackendIndividualNeighbourExpansionQueue);
973 mUseBackendIndividualNeighbourExpansionQueue = mBackendIndividualNeighbourExpansionQueue;
974 }
975 return mUseBackendIndividualNeighbourExpansionQueue;
976 }
977
978
979 CProcessingDataBox* CProcessingDataBox::clearBackendIndividualNeighbourExpansionQueue() {
980 mBackendIndividualNeighbourExpansionQueue = nullptr;
981 mUseBackendIndividualNeighbourExpansionQueue = nullptr;
982 mPrevBackendIndividualNeighbourExpansionQueue = nullptr;
983 return this;
984 }
985
986
987
988
989
990 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getDelayingNominalProcessingQueue(bool create) {
991 if (!mDelayNomProcessQueue && create) {
992 mDelayNomProcessQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
993 mDelayNomProcessQueue->initProcessingQueue(mPrevDelayNomProcessQueue);
994 mUseDelayNomProcessQueue = mDelayNomProcessQueue;
995 }
996 return mUseDelayNomProcessQueue;
997 }
998
999
1000 CProcessingDataBox* CProcessingDataBox::clearDelayingNominalProcessingQueue() {
1001 mDelayNomProcessQueue = nullptr;
1002 mUseDelayNomProcessQueue = nullptr;
1003 mPrevDelayNomProcessQueue = nullptr;
1004 return this;
1005 }
1006
1007
1008
1009 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getNominalCachingLossReactivationProcessingQueue(bool create) {
1010 if (!mCachingLossReactivationProcessQueue && create) {
1011 mCachingLossReactivationProcessQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1012 mCachingLossReactivationProcessQueue->initProcessingQueue(mPrevCachingLossReactivationProcessQueue);
1013 mUseCachingLossReactivationProcessQueue = mCachingLossReactivationProcessQueue;
1014 }
1015 return mUseCachingLossReactivationProcessQueue;
1016 }
1017
1018
1019 CProcessingDataBox* CProcessingDataBox::clearNominalCachingLossReactivationProcessingQueue() {
1020 mCachingLossReactivationProcessQueue = nullptr;
1021 mUseCachingLossReactivationProcessQueue = nullptr;
1022 mPrevCachingLossReactivationProcessQueue = nullptr;
1023 return this;
1024 }
1025
1026
1027 CIndividualConceptBatchProcessingQueue* CProcessingDataBox::getVariableBindingConceptBatchProcessingQueue(bool create) {
1028 if (!mVarBindConceptBatchProcessQueue && create) {
1029 mVarBindConceptBatchProcessQueue = CObjectParameterizingAllocator< CIndividualConceptBatchProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1030 mVarBindConceptBatchProcessQueue->initProcessingQueue(mPrevVarBindConceptBatchProcessQueue);
1031 mUseVarBindConceptBatchProcessQueue = mVarBindConceptBatchProcessQueue;
1032 }
1033 return mUseVarBindConceptBatchProcessQueue;
1034 }
1035
1036 CProcessingDataBox* CProcessingDataBox::clearVariableBindingConceptBatchProcessingQueue() {
1037 mVarBindConceptBatchProcessQueue = nullptr;
1038 mUseVarBindConceptBatchProcessQueue = nullptr;
1039 mPrevVarBindConceptBatchProcessQueue = nullptr;
1040 return this;
1041 }
1042
1043
1044
1045 CIndividualDepthProcessingQueue* CProcessingDataBox::getIndividualDepthProcessingQueue(bool create) {
1046 if (!mIndiDepthProcessingQueue && create) {
1047 mIndiDepthProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1048 mIndiDepthProcessingQueue->initProcessingQueue(mPrevIndiDepthProcessingQueue);
1049 mUseIndiDepthProcessingQueue = mIndiDepthProcessingQueue;
1050 }
1051 return mUseIndiDepthProcessingQueue;
1052 }
1053
1054
1055 CProcessingDataBox* CProcessingDataBox::clearIndividualDepthProcessingQueue() {
1056 mIndiDepthProcessingQueue = nullptr;
1057 mUseIndiDepthProcessingQueue = nullptr;
1058 mPrevIndiDepthProcessingQueue = nullptr;
1059 return this;
1060 }
1061
1062
1063
1064
1065
1066
1067
1068 CIndividualDepthProcessingQueue* CProcessingDataBox::getNominalDeterministicProcessingQueue(bool create) {
1069 if (!mNominalDeterministicProcessingQueue && create) {
1070 mNominalDeterministicProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
1071 mNominalDeterministicProcessingQueue->initProcessingQueue(mPrevNominalDeterministicProcessingQueue);
1072 mUseNominalDeterministicProcessingQueue = mNominalDeterministicProcessingQueue;
1073 }
1074 return mUseNominalDeterministicProcessingQueue;
1075 }
1076
1077
1078 CProcessingDataBox* CProcessingDataBox::clearNominalDeterministicProcessingQueue() {
1079 mNominalDeterministicProcessingQueue = nullptr;
1080 mUseNominalDeterministicProcessingQueue = nullptr;
1081 mPrevNominalDeterministicProcessingQueue = nullptr;
1082 return this;
1083 }
1084
1085
1086
1087
1088 CIndividualDepthProcessingQueue* CProcessingDataBox::getNominalProcessingQueue(bool create) {
1089 if (!mNominalProcessingQueue && create) {
1090 mNominalProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1091 mNominalProcessingQueue->initProcessingQueue(mPrevNominalProcessingQueue);
1092 mUseNominalProcessingQueue = mNominalProcessingQueue;
1093 }
1094 return mUseNominalProcessingQueue;
1095 }
1096
1097
1098 CProcessingDataBox* CProcessingDataBox::clearNominalProcessingQueue() {
1099 mNominalProcessingQueue = nullptr;
1100 mUseNominalProcessingQueue = nullptr;
1101 mPrevNominalProcessingQueue = nullptr;
1102 return this;
1103 }
1104
1105
1106
1107
1108
1109
1110 CIndividualDepthProcessingQueue* CProcessingDataBox::getIncrementalExpansionInitializingProcessingQueue(bool create) {
1111 if (!mIncrementalExansionInitializingProcessingQueue && create) {
1112 mIncrementalExansionInitializingProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1113 mIncrementalExansionInitializingProcessingQueue->initProcessingQueue(mPrevIncrementalExansionInitializingProcessingQueue);
1114 mUseIncrementalExansionInitializingProcessingQueue = mIncrementalExansionInitializingProcessingQueue;
1115 }
1116 return mUseIncrementalExansionInitializingProcessingQueue;
1117 }
1118
1119
1120 CProcessingDataBox* CProcessingDataBox::clearIncrementalExpansionInitializingProcessingQueue() {
1121 mIncrementalExansionInitializingProcessingQueue = nullptr;
1122 mUseIncrementalExansionInitializingProcessingQueue = nullptr;
1123 mPrevIncrementalExansionInitializingProcessingQueue = nullptr;
1124 return this;
1125 }
1126
1127
1128
1129
1130
1131 CIndividualCustomPriorityProcessingQueue* CProcessingDataBox::getIncrementalExpansionProcessingQueue(bool create) {
1132 if (!mIncrementalExansionProcessingQueue && create) {
1133 mIncrementalExansionProcessingQueue = CObjectParameterizingAllocator< CIndividualCustomPriorityProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1134 mIncrementalExansionProcessingQueue->initProcessingQueue(mPrevIncrementalExansionProcessingQueue);
1135 mUseIncrementalExansionProcessingQueue = mIncrementalExansionProcessingQueue;
1136 }
1137 return mUseIncrementalExansionProcessingQueue;
1138 }
1139
1140
1141 CProcessingDataBox* CProcessingDataBox::clearIncrementalExpansionIProcessingQueue() {
1142 mIncrementalExansionProcessingQueue = nullptr;
1143 mUseIncrementalExansionProcessingQueue = nullptr;
1144 mPrevIncrementalExansionProcessingQueue = nullptr;
1145 return this;
1146 }
1147
1148
1149
1150
1151
1152 CIndividualDepthProcessingQueue* CProcessingDataBox::getIncrementalCompatibilityCheckingQueue(bool create) {
1153 if (!mIncrementalCompatibilityCheckingQueue && create) {
1154 mIncrementalCompatibilityCheckingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1155 mIncrementalCompatibilityCheckingQueue->initProcessingQueue(mPrevIncrementalCompatibilityCheckingQueue);
1156 mUseIncrementalCompatibilityCheckingQueue = mIncrementalCompatibilityCheckingQueue;
1157 }
1158 return mUseIncrementalCompatibilityCheckingQueue;
1159 }
1160
1161
1162 CProcessingDataBox* CProcessingDataBox::clearIncrementalCompatibilityCheckingQueue() {
1163 mIncrementalCompatibilityCheckingQueue = nullptr;
1164 mUseIncrementalCompatibilityCheckingQueue = nullptr;
1165 mPrevIncrementalCompatibilityCheckingQueue = nullptr;
1166 return this;
1167 }
1168
1169
1170
1171
1172 CIndividualUnsortedProcessingQueue* CProcessingDataBox::getIndividualDepthFirstDeterministicExpansionProcessingQueue(bool create) {
1173 if (!mIndiDepthFirstDetExpPreProcessingQueue && create) {
1174 mIndiDepthFirstDetExpPreProcessingQueue = CObjectParameterizingAllocator< CIndividualUnsortedProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1175 mIndiDepthFirstDetExpPreProcessingQueue->initProcessingQueue(mPrevIndiDepthFirstDetExpPreProcessingQueue);
1176 mUseIndiDepthFirstDetExpPreProcessingQueue = mIndiDepthFirstDetExpPreProcessingQueue;
1177 }
1178 return mUseIndiDepthFirstDetExpPreProcessingQueue;
1179 }
1180
1181 CProcessingDataBox* CProcessingDataBox::clearIndividualDepthFirstDeterministicExpansionProcessingQueue() {
1182 mIndiDepthFirstDetExpPreProcessingQueue = nullptr;
1183 mUseIndiDepthFirstDetExpPreProcessingQueue = nullptr;
1184 mPrevIndiDepthFirstDetExpPreProcessingQueue = nullptr;
1185 return this;
1186 }
1187
1188
1189
1190 CIndividualDepthProcessingQueue* CProcessingDataBox::getIndividualDepthDeterministicExpansionPreprocessingQueue(bool create) {
1191 if (!mIndiDepthDetExpPreProcessingQueue && create) {
1192 mIndiDepthDetExpPreProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1193 mIndiDepthDetExpPreProcessingQueue->initProcessingQueue(mPrevIndiDepthDetExpPreProcessingQueue);
1194 mUseIndiDepthDetExpPreProcessingQueue = mIndiDepthDetExpPreProcessingQueue;
1195 }
1196 return mUseIndiDepthDetExpPreProcessingQueue;
1197 }
1198
1199
1200 CProcessingDataBox* CProcessingDataBox::clearIndividualDepthDeterministicExpansionPreprocessingQueue() {
1201 mIndiDepthDetExpPreProcessingQueue = nullptr;
1202 mUseIndiDepthDetExpPreProcessingQueue = nullptr;
1203 mPrevIndiDepthDetExpPreProcessingQueue = nullptr;
1204 return this;
1205 }
1206
1207
1208
1209 CIndividualDepthProcessingQueue* CProcessingDataBox::getBlockingUpdateReviewProcessingQueue(bool create) {
1210 if (!mIndiSignatureBlockingUpdateProcessingQueue && create) {
1211 mIndiSignatureBlockingUpdateProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1212 mIndiSignatureBlockingUpdateProcessingQueue->initProcessingQueue(mPrevIndiSignatureBlockingUpdateProcessingQueue);
1213 mUseIndiSignatureBlockingUpdateProcessingQueue = mIndiSignatureBlockingUpdateProcessingQueue;
1214 }
1215 return mUseIndiSignatureBlockingUpdateProcessingQueue;
1216 }
1217
1218
1219 CProcessingDataBox* CProcessingDataBox::clearBlockingUpdateReviewProcessingQueue() {
1220 mIndiSignatureBlockingUpdateProcessingQueue = nullptr;
1221 mUseIndiSignatureBlockingUpdateProcessingQueue = nullptr;
1222 mPrevIndiSignatureBlockingUpdateProcessingQueue = nullptr;
1223 return this;
1224 }
1225
1226
1227 CIndividualDepthProcessingQueue* CProcessingDataBox::getBlockedReactivationProcessingQueue(bool create) {
1228 if (!mIndiBlockedReactivationProcessingQueue && create) {
1229 mIndiBlockedReactivationProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1230 mIndiBlockedReactivationProcessingQueue->initProcessingQueue(mPrevIndiBlockedReactivationProcessingQueue);
1231 mUseIndiBlockedReactivationProcessingQueue = mIndiBlockedReactivationProcessingQueue;
1232 }
1233 return mUseIndiBlockedReactivationProcessingQueue;
1234 }
1235
1236
1237 CProcessingDataBox* CProcessingDataBox::clearBlockedReactivationProcessingQueue() {
1238 mIndiBlockedReactivationProcessingQueue = nullptr;
1239 mUseIndiBlockedReactivationProcessingQueue = nullptr;
1240 mPrevIndiBlockedReactivationProcessingQueue = nullptr;
1241 return this;
1242 }
1243
1244
1245
1246
1247 CIndividualDepthProcessingQueue* CProcessingDataBox::getValueSpaceTriggeringProcessingQueue(bool create) {
1248 if (!mValueSpaceTriggeringProcessingQueue && create) {
1249 mValueSpaceTriggeringProcessingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1250 mValueSpaceTriggeringProcessingQueue->initProcessingQueue(mPrevValueSpaceTriggeringProcessingQueue);
1251 mUseValueSpaceTriggeringProcessingQueue = mValueSpaceTriggeringProcessingQueue;
1252 }
1253 return mUseValueSpaceTriggeringProcessingQueue;
1254 }
1255
1256
1257 CProcessingDataBox* CProcessingDataBox::clearValueSpaceTriggeringProcessingQueue() {
1258 mValueSpaceTriggeringProcessingQueue = nullptr;
1259 mUseValueSpaceTriggeringProcessingQueue = nullptr;
1260 mPrevValueSpaceTriggeringProcessingQueue = nullptr;
1261 return this;
1262 }
1263
1264
1265
1266
1267
1268
1269 CIndividualDepthProcessingQueue* CProcessingDataBox::getDistinctValueSpaceSatisfiabilityCheckingQueue(bool create) {
1270 if (!mDistinctValueSpaceSatisfiabilityCheckingQueue && create) {
1271 mDistinctValueSpaceSatisfiabilityCheckingQueue = CObjectParameterizingAllocator< CIndividualDepthProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1272 mDistinctValueSpaceSatisfiabilityCheckingQueue->initProcessingQueue(mPrevDistinctValueSpaceSatisfiabilityCheckingQueue);
1273 mUseDistinctValueSpaceSatisfiabilityCheckingQueue = mDistinctValueSpaceSatisfiabilityCheckingQueue;
1274 }
1275 return mUseDistinctValueSpaceSatisfiabilityCheckingQueue;
1276 }
1277
1278
1279 CProcessingDataBox* CProcessingDataBox::clearDistinctValueSpaceSatisfiabilityCheckingQueue() {
1280 mDistinctValueSpaceSatisfiabilityCheckingQueue = nullptr;
1281 mUseDistinctValueSpaceSatisfiabilityCheckingQueue = nullptr;
1282 mPrevDistinctValueSpaceSatisfiabilityCheckingQueue = nullptr;
1283 return this;
1284 }
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295 CProcessingDataBox* CProcessingDataBox::setSignatureBlockingCandidateHash(CSignatureBlockingCandidateHash* signatureHash) {
1296 mSignatureBlockingCandidateHash = signatureHash;
1297 mUseSignatureBlockingCandidateHash = signatureHash;
1298 return this;
1299 }
1300
1301
1302 CSignatureBlockingCandidateHash* CProcessingDataBox::getSignatureBlockingCandidateHash(bool create) {
1303 if (!mSignatureBlockingCandidateHash && create) {
1304 mSignatureBlockingCandidateHash = CObjectParameterizingAllocator< CSignatureBlockingCandidateHash,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1305 mSignatureBlockingCandidateHash->initSignatureBlockingCandidateHash(mPrevSignatureBlockingCandidateHash);
1306 mUseSignatureBlockingCandidateHash = mSignatureBlockingCandidateHash;
1307 }
1308 return mUseSignatureBlockingCandidateHash;
1309 }
1310
1311
1312
1313 CSignatureBlockingCandidateHash* CProcessingDataBox::getSignatureNominalDelayingCandidateHash(bool create) {
1314 if (!mSignatureNominalDelayingCandidateHash && create) {
1315 mSignatureNominalDelayingCandidateHash = CObjectParameterizingAllocator< CSignatureBlockingCandidateHash,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1316 mSignatureNominalDelayingCandidateHash->initSignatureBlockingCandidateHash(mPrevSignatureNominalDelayingCandidateHash);
1317 mUseSignatureNominalDelayingCandidateHash = mSignatureNominalDelayingCandidateHash;
1318 }
1319 return mUseSignatureNominalDelayingCandidateHash;
1320 }
1321
1322
1323
1324 CBlockingIndividualNodeCandidateHash* CProcessingDataBox::getBlockingIndividualNodeCandidateHash(bool create) {
1325 if (!mBlockingIndiNodeCandidateHash && create) {
1326 mBlockingIndiNodeCandidateHash = CObjectParameterizingAllocator< CBlockingIndividualNodeCandidateHash,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1327 mBlockingIndiNodeCandidateHash->initBlockingIndividualNodeCandidateHash(mPrevBlockingIndiNodeCandidateHash);
1328 mUseBlockingIndiNodeCandidateHash = mBlockingIndiNodeCandidateHash;
1329 }
1330 return mUseBlockingIndiNodeCandidateHash;
1331 }
1332
1333 CBlockingIndividualNodeLinkedCandidateHash* CProcessingDataBox::getBlockingIndividualNodeLinkedCandidateHash(bool create) {
1334 if (!mBlockingIndiNodeLinkedCandidateHash && create) {
1335 mBlockingIndiNodeLinkedCandidateHash = CObjectParameterizingAllocator< CBlockingIndividualNodeLinkedCandidateHash,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1336 mBlockingIndiNodeLinkedCandidateHash->initBlockingIndividualNodeCandidateHash(mPrevBlockingIndiNodeLinkedCandidateHash);
1337 mUseBlockingIndiNodeLinkedCandidateHash = mBlockingIndiNodeLinkedCandidateHash;
1338 }
1339 return mUseBlockingIndiNodeLinkedCandidateHash;
1340 }
1341
1342 CSignatureBlockingReviewSet* CProcessingDataBox::getSignatureBlockingReviewSet(bool create) {
1343 if (!mSignatureBlockingReviewSet && create) {
1344 mSignatureBlockingReviewSet = CObjectParameterizingAllocator< CSignatureBlockingReviewSet,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1345 mSignatureBlockingReviewSet->initSignatureBlockingReviewSet(mPrevSignatureBlockingReviewSet);
1346 mUseSignatureBlockingReviewSet = mSignatureBlockingReviewSet;
1347 }
1348 return mUseSignatureBlockingReviewSet;
1349 }
1350
1351 CIndividualReactivationProcessingQueue* CProcessingDataBox::getEarlyIndividualReactivationProcessingQueue(bool create) {
1352 if (!mEarlyIndiReactProQueue && create) {
1353 mEarlyIndiReactProQueue = CObjectParameterizingAllocator< CIndividualReactivationProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1354 mEarlyIndiReactProQueue->initProcessingQueue(mPrevEarlyIndiReactProQueue);
1355 mUseEarlyIndiReactProQueue = mEarlyIndiReactProQueue;
1356 }
1357 return mUseEarlyIndiReactProQueue;
1358 }
1359
1360 CProcessingDataBox* CProcessingDataBox::clearEarlyIndividualReactivationProcessingQueue() {
1361 mEarlyIndiReactProQueue = nullptr;
1362 mUseEarlyIndiReactProQueue = nullptr;
1363 mPrevEarlyIndiReactProQueue = nullptr;
1364 return this;
1365 }
1366
1367
1368
1369
1370
1371 CIndividualReactivationProcessingQueue* CProcessingDataBox::getLateIndividualReactivationProcessingQueue(bool create) {
1372 if (!mLateIndiReactProQueue && create) {
1373 mLateIndiReactProQueue = CObjectParameterizingAllocator< CIndividualReactivationProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1374 mLateIndiReactProQueue->initProcessingQueue(mPrevLateIndiReactProQueue);
1375 mUseLateIndiReactProQueue = mLateIndiReactProQueue;
1376 }
1377 return mUseLateIndiReactProQueue;
1378 }
1379
1380 CProcessingDataBox* CProcessingDataBox::clearLateIndividualReactivationProcessingQueue() {
1381 mLateIndiReactProQueue = nullptr;
1382 mUseLateIndiReactProQueue = nullptr;
1383 mPrevLateIndiReactProQueue = nullptr;
1384 return this;
1385 }
1386
1387
1388 CProcessingDataBox* CProcessingDataBox::clearSignatureBlockingReviewSet() {
1389 mUseSignatureBlockingReviewSet = nullptr;
1390 mSignatureBlockingReviewSet = nullptr;
1391 mPrevSignatureBlockingReviewSet = nullptr;
1392 return this;
1393 }
1394
1395 CProcessingDataBox* CProcessingDataBox::clearReusingReviewData() {
1396 mReusingReviewSet = nullptr;
1397 mUseReusingReviewSet = nullptr;
1398 mPrevReusingReviewSet = nullptr;
1399 return this;
1400 }
1401
1402 CReusingReviewData* CProcessingDataBox::getReusingReviewData(bool create) {
1403 if (!mReusingReviewSet && create) {
1404 mReusingReviewSet = CObjectParameterizingAllocator< CReusingReviewData,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1405 mReusingReviewSet->initReviewData(mPrevReusingReviewSet);
1406 mUseReusingReviewSet = mReusingReviewSet;
1407 }
1408 return mUseReusingReviewSet;
1409 }
1410
1411 CNodeSwitchHistory* CProcessingDataBox::getNodeSwitchHistory(bool create) {
1412 if (!mNodeSwitchHistory && create) {
1413 mNodeSwitchHistory = CObjectParameterizingAllocator< CNodeSwitchHistory,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1414 mNodeSwitchHistory->initSwitchHistory(mPrevNodeSwitchHistory);
1415 mUseNodeSwitchHistory = mNodeSwitchHistory;
1416 }
1417 return mUseNodeSwitchHistory;
1418 }
1419
1420 CBranchingTree* CProcessingDataBox::getBranchingTree(bool create) {
1421 if (!mBranchingTree && create) {
1422 mBranchingTree = CObjectParameterizingAllocator< CBranchingTree,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1423 mBranchingTree->initBranchingTree(mPrevBranchingTree);
1424 mUseBranchingTree = mBranchingTree;
1425 }
1426 return mUseBranchingTree;
1427 }
1428
1429 bool CProcessingDataBox::hasCacheTestingIndividualNodes() {
1430 return mIndividualNodeCacheTestingLinker != nullptr;
1431 }
1432
1433 CIndividualProcessNode* CProcessingDataBox::takeNextCacheTestingIndividualNode() {
1434 CXLinker<CIndividualProcessNode*>* tmpIndividualNodeCacheTestingLinker = mIndividualNodeCacheTestingLinker;
1435 if (mIndividualNodeCacheTestingLinker) {
1436 mIndividualNodeCacheTestingLinker = mIndividualNodeCacheTestingLinker->getNext();
1437 }
1438 return tmpIndividualNodeCacheTestingLinker->getData();
1439 }
1440
1441
1442 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::takeIndividualNodeCacheTestingLinker() {
1443 CXLinker<CIndividualProcessNode*>* tmpIndividualNodeCacheTestingLinker = mIndividualNodeCacheTestingLinker;
1444 mIndividualNodeCacheTestingLinker = nullptr;
1445 return tmpIndividualNodeCacheTestingLinker;
1446 }
1447
1448 CProcessingDataBox* CProcessingDataBox::addIndividualNodeCacheTestingLinker(CXLinker<CIndividualProcessNode*>* linker) {
1449 if (linker) {
1450 mIndividualNodeCacheTestingLinker = linker->append(mIndividualNodeCacheTestingLinker);
1451 }
1452 return this;
1453 }
1454
1455
1456
1457
1458
1459
1460 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::getSortedNominalNonDeterministicProcessingNodeLinker() {
1461 return mSortedNominalNonDetProcessingNodeLinker;
1462 }
1463
1464
1465 bool CProcessingDataBox::hasSortedNominalNonDeterministicProcessingNodes() {
1466 return mSortedNominalNonDetProcessingNodeLinker != nullptr;
1467 }
1468
1469 CIndividualProcessNode* CProcessingDataBox::takeSortedNominalNonDeterministicProcessingNode() {
1470 CXLinker<CIndividualProcessNode*>* tmpIndividualNodeCacheTestingLinker = mSortedNominalNonDetProcessingNodeLinker;
1471 if (mSortedNominalNonDetProcessingNodeLinker) {
1472 --mNominalNonDetProcessingCount;
1473 mSortedNominalNonDetProcessingNodeLinker = mSortedNominalNonDetProcessingNodeLinker->getNext();
1474 }
1475 return tmpIndividualNodeCacheTestingLinker->getData();
1476 }
1477
1478
1479 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::takeSortedNominalNonDeterministicProcessingNodeLinker() {
1480 CXLinker<CIndividualProcessNode*>* tmpIndividualNodeCacheTestingLinker = mSortedNominalNonDetProcessingNodeLinker;
1481 mSortedNominalNonDetProcessingNodeLinker = nullptr;
1482 return tmpIndividualNodeCacheTestingLinker;
1483 }
1484
1485 CProcessingDataBox* CProcessingDataBox::addSortedNominalNonDeterministicProcessingNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
1486 if (linker) {
1487 mNominalNonDetProcessingCount += linker->getCount();
1488 mSortedNominalNonDetProcessingNodeLinker = linker->append(mSortedNominalNonDetProcessingNodeLinker);
1489 }
1490 return this;
1491 }
1492
1493 CProcessingDataBox* CProcessingDataBox::setSortedNominalNonDeterministicProcessingNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
1494 mNominalNonDetProcessingCount = linker->getCount();
1495 mSortedNominalNonDetProcessingNodeLinker = linker;
1496 return this;
1497 }
1498
1499 CProcessingDataBox* CProcessingDataBox::clearSortedNominalNonDeterministicProcessingNodeLinker() {
1500 mSortedNominalNonDetProcessingNodeLinker = nullptr;
1501 mNominalNonDetProcessingCount = 0;
1502 return this;
1503 }
1504
1505
1506 bool CProcessingDataBox::hasNominalNonDeterministicProcessingNodesSorted() {
1507 return mSortedNominalNonDetProcessingNodesSorted;
1508 }
1509
1510 CProcessingDataBox* CProcessingDataBox::setNominalNonDeterministicProcessingNodesSorted(bool sorted) {
1511 mSortedNominalNonDetProcessingNodesSorted = sorted;
1512 return this;
1513 }
1514
1515
1516
1517
1518
1519
1520 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::takeNextIndividualNodeBlockedResolveLinker() {
1521 CXLinker<CIndividualProcessNode*>* tmpIndividualNodeBlockResolveLinker = mIndividualNodeResolveLinker;
1522 if (mIndividualNodeResolveLinker) {
1523 mIndividualNodeResolveLinker = mIndividualNodeResolveLinker->getNext();
1524 }
1525 return tmpIndividualNodeBlockResolveLinker;
1526 }
1527
1528 bool CProcessingDataBox::hasBlockedResolveIndividualNodes() {
1529 return mIndividualNodeResolveLinker != nullptr;
1530 }
1531
1532 CProcessingDataBox* CProcessingDataBox::clearBlockedResolveIndividualNodes() {
1533 mIndividualNodeResolveLinker = nullptr;
1534 return this;
1535 }
1536
1537 CProcessingDataBox* CProcessingDataBox::addIndividualNodeBlockedResolveLinker(CXLinker<CIndividualProcessNode*>* linker) {
1538 if (linker) {
1539 mIndividualNodeResolveLinker = linker->append(mIndividualNodeResolveLinker);
1540 }
1541 return this;
1542 }
1543
1544
1545
1546
1547
1548
1549
1550
1551 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::getBlockableIndividualNodeUpdatedLinker() {
1552 CXLinker<CIndividualProcessNode*>* tmpIndividualNodeBlockResolveLinker = mBlockableIndividualNodeUpdatedLinker;
1553 if (mBlockableIndividualNodeUpdatedLinker) {
1554 mBlockableIndividualNodeUpdatedLinker = mBlockableIndividualNodeUpdatedLinker->getNext();
1555 }
1556 return tmpIndividualNodeBlockResolveLinker;
1557 }
1558
1559 bool CProcessingDataBox::hasBlockableIndividualNodeUpdatedLinker() {
1560 return mBlockableIndividualNodeUpdatedLinker != nullptr;
1561 }
1562
1563 CProcessingDataBox* CProcessingDataBox::clearBlockableIndividualNodeUpdatedLinker() {
1564 mBlockableIndividualNodeUpdatedLinker = nullptr;
1565 return this;
1566 }
1567
1568 CProcessingDataBox* CProcessingDataBox::addBlockableIndividualNodeUpdatedLinker(CXLinker<CIndividualProcessNode*>* linker) {
1569 if (linker) {
1570 mBlockableIndividualNodeUpdatedLinker = linker->append(mBlockableIndividualNodeUpdatedLinker);
1571 }
1572 return this;
1573 }
1574
1575
1576
1577
1578
1579 CProcessingDataBox* CProcessingDataBox::setMultipleConstructionIndividualNodes(bool multiple) {
1580 mMultipleConstructionIndiNodes = multiple;
1581 return this;
1582 }
1583
1584 bool CProcessingDataBox::hasMultipleConstructionIndividualNodes() {
1585 return mMultipleConstructionIndiNodes;
1586 }
1587
1588
1589
1590 CIndividualProcessNode* CProcessingDataBox::getConstructedIndividualNode() {
1591 return mConstructedIndiNode;
1592 }
1593
1594 CProcessingDataBox* CProcessingDataBox::setConstructedIndividualNode(CIndividualProcessNode* indiNode) {
1595 mConstructedIndiNode = indiNode;
1596 return this;
1597 }
1598
1599
1600 bool CProcessingDataBox::hasConstructedIndividualNodeInitialized() {
1601 return mConstructedIndiNodeInitialized;
1602 }
1603
1604 CProcessingDataBox* CProcessingDataBox::setConstructedIndividualNodeInitialized(bool initialized) {
1605 mConstructedIndiNodeInitialized = initialized;
1606 return this;
1607 }
1608
1609
1610 CProcessContext* CProcessingDataBox::getProcessContext() {
1611 return mProcessContext;
1612 }
1613
1614 CProcessingDataBox* CProcessingDataBox::setLastProcessingIndividualNodeAndConceptDescriptor(CIndividualProcessNode* indiNode, CConceptProcessDescriptor* conDes) {
1615 mLastProcessingIndiNode = indiNode;
1616 mLastProcessingConDes = conDes;
1617 return this;
1618 }
1619
1620 bool CProcessingDataBox::getLastProcessingIndividualNodeAndConceptDescriptor(CIndividualProcessNode*& indiNode, CConceptProcessDescriptor*& conDes) {
1621 if (mLastProcessingIndiNode && mLastProcessingConDes) {
1622 indiNode = mLastProcessingIndiNode;
1623 conDes = mLastProcessingConDes;
1624 return true;
1625 }
1626 return false;
1627 }
1628
1629 bool CProcessingDataBox::hasLastProcessingIndividualNodeAndConceptDescriptor() {
1630 return mLastProcessingConDes && mLastProcessingIndiNode;
1631 }
1632
1633 bool CProcessingDataBox::isReapplicationLastConceptDesciptorOnLastIndividualNodeRequired() {
1634 return mLastConDesIndiReapplication;
1635 }
1636
1637 CProcessingDataBox* CProcessingDataBox::setReapplicationLastConceptDesciptorOnLastIndividualNodeRequired(bool requiresReapplication) {
1638 mLastConDesIndiReapplication = requiresReapplication;
1639 return this;
1640 }
1641
1642 CIndividualProcessNodeLinker* CProcessingDataBox::getIndividualProcessNodeLinker() {
1643 return mIndiProcessNodeLinker;
1644 }
1645
1646 CIndividualProcessNodeLinker* CProcessingDataBox::takeIndividualProcessNodeLinker() {
1647 CIndividualProcessNodeLinker* indiProcNodeLinker = mIndiProcessNodeLinker;
1648 if (mIndiProcessNodeLinker) {
1649 mIndiProcessNodeLinker = mIndiProcessNodeLinker->getNext();
1650 indiProcNodeLinker->clearNext();
1651 }
1652 return indiProcNodeLinker;
1653 }
1654
1655 CProcessingDataBox* CProcessingDataBox::setIndividualProcessNodeLinker(CIndividualProcessNodeLinker* indiProcessNodeLinker) {
1656 mIndiProcessNodeLinker = indiProcessNodeLinker;
1657 return this;
1658 }
1659
1660
1661 CProcessingDataBox* CProcessingDataBox::addIndividualProcessNodeLinker(CIndividualProcessNodeLinker* indiProcessNodeLinker) {
1662 mIndiProcessNodeLinker = indiProcessNodeLinker->append(mIndiProcessNodeLinker);
1663 return this;
1664 }
1665
1666
1667
1668 CProcessingDataBox* CProcessingDataBox::setMaximumDeterministicBranchTag(cint64 branchTag) {
1669 mMaximumDeterministicBranchTag = branchTag;
1670 return this;
1671 }
1672
1673 cint64 CProcessingDataBox::getMaximumDeterministicBranchTag() {
1674 return mMaximumDeterministicBranchTag;
1675 }
1676
1677
1678
1679
1680 CIndividualSaturationProcessNodeVector* CProcessingDataBox::getIndividualSaturationProcessNodeVector(bool create) {
1681 if (!mIndiSaturationProcessVector && create) {
1682 mIndiSaturationProcessVector = CObjectParameterizingAllocator< CIndividualSaturationProcessNodeVector,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1683 }
1684 return mIndiSaturationProcessVector;
1685 }
1686
1687 bool CProcessingDataBox::hasIndividualSaturationProcessNodeLinker() {
1688 return mIndiSaturationProcessNodeLinker != nullptr;
1689 }
1690
1691 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getIndividualSaturationProcessNodeLinker() {
1692 return mIndiSaturationProcessNodeLinker;
1693 }
1694
1695 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeIndividualSaturationProcessNodeLinker() {
1696 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mIndiSaturationProcessNodeLinker;
1697 if (mIndiSaturationProcessNodeLinker) {
1698 mIndiSaturationProcessNodeLinker = mIndiSaturationProcessNodeLinker->getNext();
1699 indiProcNodeLinker->clearNext();
1700 }
1701 return indiProcNodeLinker;
1702 }
1703
1704 CProcessingDataBox* CProcessingDataBox::setIndividualSaturationProcessNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
1705 mIndiSaturationProcessNodeLinker = indiProcessNodeLinker;
1706 return this;
1707 }
1708
1709
1710 CProcessingDataBox* CProcessingDataBox::addIndividualSaturationProcessNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
1711 mIndiSaturationProcessNodeLinker = indiProcessNodeLinker->append(mIndiSaturationProcessNodeLinker);
1712 return this;
1713 }
1714
1715
1716
1717
1718 bool CProcessingDataBox::hasIndividualDisjunctCommonConceptExtractProcessLinker() {
1719 return mDisjunctCommonConceptExtractProcessingLinker != nullptr;
1720 }
1721
1722 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getIndividualDisjunctCommonConceptExtractProcessLinker() {
1723 return mDisjunctCommonConceptExtractProcessingLinker;
1724 }
1725
1726 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeIndividualDisjunctCommonConceptExtractProcessLinker() {
1727 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mDisjunctCommonConceptExtractProcessingLinker;
1728 if (mDisjunctCommonConceptExtractProcessingLinker) {
1729 mDisjunctCommonConceptExtractProcessingLinker = mDisjunctCommonConceptExtractProcessingLinker->getNext();
1730 indiProcNodeLinker->clearNext();
1731 }
1732 return indiProcNodeLinker;
1733 }
1734
1735 CProcessingDataBox* CProcessingDataBox::setIndividualDisjunctCommonConceptExtractProcessLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
1736 mDisjunctCommonConceptExtractProcessingLinker = indiProcessNodeLinker;
1737 return this;
1738 }
1739
1740
1741 CProcessingDataBox* CProcessingDataBox::addIndividualDisjunctCommonConceptExtractProcessLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
1742 mDisjunctCommonConceptExtractProcessingLinker = indiProcessNodeLinker->append(mDisjunctCommonConceptExtractProcessingLinker);
1743 return this;
1744 }
1745
1746
1747
1748
1749 CConceptSaturationProcessLinker* CProcessingDataBox::getRemainingConceptSaturationProcessLinker() {
1750 return mRemConSatProcessLinker;
1751 }
1752
1753 CConceptSaturationProcessLinker* CProcessingDataBox::takeRemainingConceptSaturationProcessLinker() {
1754 CConceptSaturationProcessLinker* conSatProLinker = mRemConSatProcessLinker;
1755 if (mRemConSatProcessLinker) {
1756 mRemConSatProcessLinker = mRemConSatProcessLinker->getNext();
1757 conSatProLinker->clearNext();
1758 }
1759 return conSatProLinker;
1760 }
1761
1762 CIndividualSaturationProcessNodeStatusUpdateLinker* CProcessingDataBox::getRemainingIndividualSaturationUpdateLinker() {
1763 return mRemSatUpdateLinker;
1764 }
1765
1766 CIndividualSaturationProcessNodeStatusUpdateLinker* CProcessingDataBox::takeRemainingIndividualSaturationUpdateLinker() {
1767 CIndividualSaturationProcessNodeStatusUpdateLinker* conSatUpdLinker = mRemSatUpdateLinker;
1768 if (mRemSatUpdateLinker) {
1769 mRemSatUpdateLinker = mRemSatUpdateLinker->getNext();
1770 conSatUpdLinker->clearNext();
1771 }
1772 return conSatUpdLinker;
1773 }
1774
1775 CProcessingDataBox* CProcessingDataBox::addRemainingIndividualSaturationUpdateLinker(CIndividualSaturationProcessNodeStatusUpdateLinker* indiSaturationUpdateLinker) {
1776 mRemSatUpdateLinker = indiSaturationUpdateLinker->append(mRemSatUpdateLinker);
1777 return this;
1778 }
1779
1780 CProcessingDataBox* CProcessingDataBox::setRemainingIndividualSaturationUpdateLinker(CIndividualSaturationProcessNodeStatusUpdateLinker* indiSaturationUpdateLinker) {
1781 mRemSatUpdateLinker = indiSaturationUpdateLinker;
1782 return this;
1783 }
1784
1785
1786 CProcessingDataBox* CProcessingDataBox::setRemainingConceptSaturationProcessLinker(CConceptSaturationProcessLinker* conSatProcessLinker) {
1787 mRemConSatProcessLinker = conSatProcessLinker;
1788 return this;
1789 }
1790
1791 CProcessingDataBox* CProcessingDataBox::addRemainingConceptSaturationProcessLinker(CConceptSaturationProcessLinker* conSatProcessLinker) {
1792 mRemConSatProcessLinker = conSatProcessLinker->append(mRemConSatProcessLinker);
1793 return this;
1794 }
1795
1796 CConceptDescriptor* CProcessingDataBox::getRemainingConceptDescriptor() {
1797 return mRemConDes;
1798 }
1799
1800 CConceptDescriptor* CProcessingDataBox::takeRemainingConceptDescriptor() {
1801 CConceptDescriptor* conDes = mRemConDes;
1802 if (mRemConDes) {
1803 mRemConDes = mRemConDes->getNext();
1804 conDes->clearNext();
1805 }
1806 return conDes;
1807 }
1808
1809 CProcessingDataBox* CProcessingDataBox::setRemainingConceptDescriptor(CConceptDescriptor* conDes) {
1810 mRemConDes = conDes;
1811 return this;
1812 }
1813
1814 CProcessingDataBox* CProcessingDataBox::addRemainingConceptDescriptor(CConceptDescriptor* conDes) {
1815 mRemConDes = conDes->append(mRemConDes);
1816 return this;
1817 }
1818
1819
1820
1821
1822
1823
1824 CConceptSaturationDescriptor* CProcessingDataBox::getRemainingConceptSaturationDescriptor() {
1825 return mRemConSatDes;
1826 }
1827
1828 CConceptSaturationDescriptor* CProcessingDataBox::takeRemainingConceptSaturationDescriptor() {
1829 CConceptSaturationDescriptor* conSatDes = mRemConSatDes;
1830 if (mRemConSatDes) {
1831 mRemConSatDes = mRemConSatDes->getNext();
1832 conSatDes->clearNext();
1833 }
1834 return conSatDes;
1835 }
1836
1837 CProcessingDataBox* CProcessingDataBox::setRemainingConceptSaturationDescriptor(CConceptSaturationDescriptor* conSatDes) {
1838 mRemConSatDes = conSatDes;
1839 return this;
1840 }
1841
1842 CProcessingDataBox* CProcessingDataBox::addRemainingConceptSaturationDescriptor(CConceptSaturationDescriptor* conSatDes) {
1843 mRemConSatDes = conSatDes->append(mRemConSatDes);
1844 return this;
1845 }
1846
1847
1848
1849 CRoleSaturationProcessLinker* CProcessingDataBox::getRemainingRoleSaturationProcessLinker() {
1850 return mRemRoleSatProcessLinker;
1851 }
1852
1853 CRoleSaturationProcessLinker* CProcessingDataBox::takeRemainingRoleSaturationProcessLinker() {
1854 CRoleSaturationProcessLinker* roleProDes = mRemRoleSatProcessLinker;
1855 if (mRemRoleSatProcessLinker) {
1856 mRemRoleSatProcessLinker = mRemRoleSatProcessLinker->getNext();
1857 roleProDes->clearNext();
1858 }
1859 return roleProDes;
1860 }
1861
1862 CProcessingDataBox* CProcessingDataBox::setRemainingRoleSaturationProcessLinker(CRoleSaturationProcessLinker* roleProcessLinker) {
1863 mRemRoleSatProcessLinker = roleProcessLinker;
1864 return this;
1865 }
1866
1867 CProcessingDataBox* CProcessingDataBox::addRemainingRoleSaturationProcessLinker(CRoleSaturationProcessLinker* roleProcessLinker) {
1868 mRemRoleSatProcessLinker = roleProcessLinker->append(mRemRoleSatProcessLinker);
1869 return this;
1870 }
1871
1872
1873
1874
1875
1876
1877
1878
1879 CCriticalIndividualNodeConceptTestSet* CProcessingDataBox::getSaturationCriticalIndividualNodeConceptTestSet(bool create) {
1880 if (!mSatCriticalIndiNodeConTestSet && create) {
1881 mSatCriticalIndiNodeConTestSet = CObjectParameterizingAllocator< CCriticalIndividualNodeConceptTestSet,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1882 mSatCriticalIndiNodeConTestSet->initIndividualNodeConceptTestSet(nullptr);
1883 }
1884 return mSatCriticalIndiNodeConTestSet;
1885 }
1886
1887
1888
1889
1890 CSaturationNominalDependentNodeHash* CProcessingDataBox::getSaturationNominalDependentNodeHash(bool create) {
1891 if (!mSatNominalDependentNodeHash && create) {
1892 mSatNominalDependentNodeHash = CObjectParameterizingAllocator< CSaturationNominalDependentNodeHash,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1893 mSatNominalDependentNodeHash->initNominalDependentNodeHash(nullptr);
1894 }
1895 return mSatNominalDependentNodeHash;
1896 }
1897
1898
1899
1900 CSaturationInfluencedNominalSet* CProcessingDataBox::getSaturationInfluencedNominalSet(bool create) {
1901 if (!mSatInfluencedNominalSet && create) {
1902 mSatInfluencedNominalSet = CObjectParameterizingAllocator< CSaturationInfluencedNominalSet,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1903 mSatInfluencedNominalSet->initInfluencedNominalSet(nullptr);
1904 }
1905 return mSatInfluencedNominalSet;
1906 }
1907
1908
1909
1910
1911 CSaturationSuccessorExtensionIndividualNodeProcessingQueue* CProcessingDataBox::getSaturationSucessorExtensionIndividualNodeProcessingQueue(bool create) {
1912 if (!mSatSuccExtIndNodeProcQueue && create) {
1913 mSatSuccExtIndNodeProcQueue = CObjectParameterizingAllocator< CSaturationSuccessorExtensionIndividualNodeProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1914 mSatSuccExtIndNodeProcQueue->initProcessingQueue(nullptr);
1915 }
1916 return mSatSuccExtIndNodeProcQueue;
1917 }
1918
1919 CCriticalIndividualNodeProcessingQueue* CProcessingDataBox::getSaturationCriticalIndividualNodeProcessingQueue(bool create) {
1920 if (!mSatCriticalIndiNodeProcQueue && create) {
1921 mSatCriticalIndiNodeProcQueue = CObjectParameterizingAllocator< CCriticalIndividualNodeProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
1922 mSatCriticalIndiNodeProcQueue->initProcessingQueue(nullptr);
1923 }
1924 return mSatCriticalIndiNodeProcQueue;
1925 }
1926
1927
1928 bool CProcessingDataBox::isInsufficientNodeOccured() {
1929 return mInsufficientNodeOccured;
1930 }
1931
1932 CProcessingDataBox* CProcessingDataBox::setInsufficientNodeOccured(bool insufficientNodeOccured) {
1933 mInsufficientNodeOccured = insufficientNodeOccured;
1934 return this;
1935 }
1936
1937 bool CProcessingDataBox::isProblematicEQCandidateOccured() {
1938 return mProblematicEQCandidateNodeOccured;
1939 }
1940
1941 CProcessingDataBox* CProcessingDataBox::setProblematicEQCandidateOccured(bool problematicNodeOccured) {
1942 mProblematicEQCandidateNodeOccured = problematicNodeOccured;
1943 return this;
1944 }
1945
1946
1947 bool CProcessingDataBox::isDelayedNominalProcessingOccured() {
1948 return mDelayedNominalProcessingOccured;
1949 }
1950
1951 CProcessingDataBox* CProcessingDataBox::setDelayedNominalProcessingOccured(bool delayedNominalProcessingOccured) {
1952 mDelayedNominalProcessingOccured = delayedNominalProcessingOccured;
1953 return this;
1954 }
1955
1956
1957
1958 bool CProcessingDataBox::hasIndividualSaturationCompletionNodeLinker() {
1959 return mIndiSaturationCompletionNodeLinker != nullptr;
1960 }
1961
1962 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getIndividualSaturationCompletionNodeLinker() {
1963 return mIndiSaturationCompletionNodeLinker;
1964 }
1965
1966 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeIndividualSaturationCompletionNodeLinker() {
1967 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mIndiSaturationCompletionNodeLinker;
1968 if (mIndiSaturationCompletionNodeLinker) {
1969 mIndiSaturationCompletionNodeLinker = mIndiSaturationCompletionNodeLinker->getNext();
1970 indiProcNodeLinker->clearNext();
1971 }
1972 return indiProcNodeLinker;
1973 }
1974
1975 CProcessingDataBox* CProcessingDataBox::setIndividualSaturationCompletionNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
1976 mIndiSaturationCompletionNodeLinker = indiProcessNodeLinker;
1977 return this;
1978 }
1979
1980
1981 CProcessingDataBox* CProcessingDataBox::addIndividualSaturationCompletionNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
1982 mIndiSaturationCompletionNodeLinker = indiProcessNodeLinker->append(mIndiSaturationCompletionNodeLinker);
1983 return this;
1984 }
1985
1986
1987
1988
1989
1990
1991
1992 bool CProcessingDataBox::hasIndividualSaturationCompletedNodeLinker() {
1993 return mIndiSaturationCompletedNodeLinker != nullptr;
1994 }
1995
1996 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getIndividualSaturationCompletedNodeLinker() {
1997 return mIndiSaturationCompletedNodeLinker;
1998 }
1999
2000 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeIndividualSaturationCompletedNodeLinker() {
2001 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mIndiSaturationCompletedNodeLinker;
2002 if (mIndiSaturationCompletedNodeLinker) {
2003 mIndiSaturationCompletedNodeLinker = mIndiSaturationCompletedNodeLinker->getNext();
2004 indiProcNodeLinker->clearNext();
2005 }
2006 return indiProcNodeLinker;
2007 }
2008
2009 CProcessingDataBox* CProcessingDataBox::setIndividualSaturationCompletedNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2010 mIndiSaturationCompletedNodeLinker = indiProcessNodeLinker;
2011 return this;
2012 }
2013
2014
2015 CProcessingDataBox* CProcessingDataBox::addIndividualSaturationCompletedNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2016 mIndiSaturationCompletedNodeLinker = indiProcessNodeLinker->append(mIndiSaturationCompletedNodeLinker);
2017 return this;
2018 }
2019
2020
2021
2022
2023
2024
2025
2026 bool CProcessingDataBox::hasIndividualSaturationAnalysationNodeLinker() {
2027 return mIndiSaturationAnalysingNodeLinker != nullptr;
2028 }
2029
2030 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getIndividualSaturationAnalysationNodeLinker() {
2031 return mIndiSaturationAnalysingNodeLinker;
2032 }
2033
2034 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeIndividualSaturationAnalysationNodeLinker() {
2035 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mIndiSaturationAnalysingNodeLinker;
2036 if (mIndiSaturationAnalysingNodeLinker) {
2037 mIndiSaturationAnalysingNodeLinker = mIndiSaturationAnalysingNodeLinker->getNext();
2038 indiProcNodeLinker->clearNext();
2039 }
2040 return indiProcNodeLinker;
2041 }
2042
2043 CProcessingDataBox* CProcessingDataBox::setIndividualSaturationAnalysationNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2044 mIndiSaturationAnalysingNodeLinker = indiProcessNodeLinker;
2045 return this;
2046 }
2047
2048
2049 CProcessingDataBox* CProcessingDataBox::addIndividualSaturationAnalysationNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2050 mIndiSaturationAnalysingNodeLinker = indiProcessNodeLinker->append(mIndiSaturationAnalysingNodeLinker);
2051 return this;
2052 }
2053
2054
2055
2056
2057
2058
2059
2060
2061 bool CProcessingDataBox::hasNominalDelayedIndividualSaturationProcessNodeLinker() {
2062 return mNominalDelayedIndiSaturationProcessNodeLinker != nullptr;
2063 }
2064
2065 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getNominalDelayedIndividualSaturationProcessNodeLinker() {
2066 return mNominalDelayedIndiSaturationProcessNodeLinker;
2067 }
2068
2069 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeNominalDelayedIndividualSaturationProcessNodeLinker() {
2070 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mNominalDelayedIndiSaturationProcessNodeLinker;
2071 if (mNominalDelayedIndiSaturationProcessNodeLinker) {
2072 mNominalDelayedIndiSaturationProcessNodeLinker = mNominalDelayedIndiSaturationProcessNodeLinker->getNext();
2073 indiProcNodeLinker->clearNext();
2074 }
2075 return indiProcNodeLinker;
2076 }
2077
2078 CProcessingDataBox* CProcessingDataBox::setNominalDelayedIndividualSaturationProcessNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2079 mNominalDelayedIndiSaturationProcessNodeLinker = indiProcessNodeLinker;
2080 return this;
2081 }
2082
2083
2084 CProcessingDataBox* CProcessingDataBox::addNominalDelayedIndividualSaturationProcessNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2085 mNominalDelayedIndiSaturationProcessNodeLinker = indiProcessNodeLinker->append(mNominalDelayedIndiSaturationProcessNodeLinker);
2086 return this;
2087 }
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097 bool CProcessingDataBox::hasSaturationATMOSTMergingProcessLinker() {
2098 return mSaturationATMOSTMergingProcessLinker != nullptr;
2099 }
2100
2101 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getSaturationATMOSTMergingProcessLinker() {
2102 return mSaturationATMOSTMergingProcessLinker;
2103 }
2104
2105 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeSaturationATMOSTMergingProcessLinker() {
2106 CIndividualSaturationProcessNodeLinker* indiProcNodeLinker = mSaturationATMOSTMergingProcessLinker;
2107 if (mSaturationATMOSTMergingProcessLinker) {
2108 mSaturationATMOSTMergingProcessLinker = mSaturationATMOSTMergingProcessLinker->getNext();
2109 indiProcNodeLinker->clearNext();
2110 }
2111 return indiProcNodeLinker;
2112 }
2113
2114 CProcessingDataBox* CProcessingDataBox::setSaturationATMOSTMergingProcessLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2115 mSaturationATMOSTMergingProcessLinker = indiProcessNodeLinker;
2116 return this;
2117 }
2118
2119
2120 CProcessingDataBox* CProcessingDataBox::addSaturationATMOSTMergingProcessLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2121 mSaturationATMOSTMergingProcessLinker = indiProcessNodeLinker->append(mSaturationATMOSTMergingProcessLinker);
2122 return this;
2123 }
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136 CIndividualSaturationProcessNode* CProcessingDataBox::getSeparatedSaturationConceptAssertionResolveNode() {
2137 return mSeparatedSaturationConAssResolveNode;
2138 }
2139
2140 CProcessingDataBox* CProcessingDataBox::setSeparatedSaturationConceptAssertionResolveNode(CIndividualSaturationProcessNode* node) {
2141 mSeparatedSaturationConAssResolveNode = node;
2142 return this;
2143 }
2144
2145
2146 bool CProcessingDataBox::isIncrementalExpansionInitialised() {
2147 return mIncrementalExpansionInitialized;
2148 }
2149
2150 CProcessingDataBox* CProcessingDataBox::setIncrementalExpansionInitialised(bool initialized) {
2151 mIncrementalExpansionInitialized = initialized;
2152 return this;
2153 }
2154
2155 cint64 CProcessingDataBox::getIncrementalExpansionID() {
2156 return mIncrementalExpID;
2157 }
2158
2159 CProcessingDataBox* CProcessingDataBox::setIncrementalExpansionID(cint64 incExpID) {
2160 mIncrementalExpID = incExpID;
2161 return this;
2162 }
2163
2164
2165 cint64 CProcessingDataBox::getMaxIncrementalPreviousCompletionGraphNodeID() {
2166 return mMaxIncPrevCompGraphNodeID;
2167 }
2168
2169 CProcessingDataBox* CProcessingDataBox::setMaxIncrementalPreviousCompletionGraphNodeID(cint64 nodeID) {
2170 mMaxIncPrevCompGraphNodeID = nodeID;
2171 return this;
2172 }
2173
2174 cint64 CProcessingDataBox::getNextIncrementalIndividualExpansionID(bool incrementNextID) {
2175 cint64 nextID = mNextIncrementalIndiExpID;
2176 if (incrementNextID) {
2177 ++mNextIncrementalIndiExpID;
2178 }
2179 return nextID;
2180 }
2181
2182 cint64 CProcessingDataBox::getNextRoleAssertionCreationID(bool incrementNextID) {
2183 cint64 nextID = mNextRoleAssertionCreationID;
2184 if (incrementNextID) {
2185 ++mNextRoleAssertionCreationID;
2186 }
2187 return nextID;
2188 }
2189
2190
2191 bool CProcessingDataBox::isIncrementalExpansionCompatibleMerged() {
2192 return mIncrementalExpansionCompatibleMerged;
2193 }
2194
2195 CProcessingDataBox* CProcessingDataBox::setIncrementalExpansionCompatibleMerged(bool compatibleMerged) {
2196 mIncrementalExpansionCompatibleMerged = compatibleMerged;
2197 return this;
2198 }
2199
2200 bool CProcessingDataBox::isIncrementalExpansionCachingMerged() {
2201 return mIncrementalExpansionCachingMerged;
2202 }
2203
2204 CProcessingDataBox* CProcessingDataBox::setIncrementalExpansionCachingMerged(bool cachingMerged) {
2205 mIncrementalExpansionCachingMerged = cachingMerged;
2206 return this;
2207 }
2208
2209 CReferredIndividualTrackingVector* CProcessingDataBox::getReferredIndividualTrackingVector() {
2210 return mReferredIndiTrackVec;
2211 }
2212
2213
2214 CProcessingDataBox* CProcessingDataBox::setReferredIndividualTrackingVector(CReferredIndividualTrackingVector* refIndiTrackVec) {
2215 mReferredIndiTrackVec = refIndiTrackVec;
2216 return this;
2217 }
2218
2219 bool CProcessingDataBox::isIndividualDependenceTrackingRequired() {
2220 return mIndiDepTrackingRequired;
2221 }
2222
2223 CProcessingDataBox* CProcessingDataBox::setIndividualDependenceTrackingRequired(bool indiDepTrackingRequired) {
2224 mIndiDepTrackingRequired = indiDepTrackingRequired;
2225 return this;
2226 }
2227
2228
2229
2230
2231
2232
2233
2234 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::getRemainingIndividualSaturationNodeLinker() {
2235 return mRemSatIndiNodeLinker;
2236 }
2237
2238 CIndividualSaturationProcessNodeLinker* CProcessingDataBox::takeRemainingIndividualSaturationNodeLinker() {
2239 CIndividualSaturationProcessNodeLinker* indiNodeSatLinker = mRemSatIndiNodeLinker;
2240 if (mRemSatIndiNodeLinker) {
2241 mRemSatIndiNodeLinker = mRemSatIndiNodeLinker->getNext();
2242 indiNodeSatLinker->clearNext();
2243 }
2244 return indiNodeSatLinker;
2245 }
2246
2247 CProcessingDataBox* CProcessingDataBox::addRemainingIndividualSaturationNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2248 mRemSatIndiNodeLinker = indiProcessNodeLinker->append(mRemSatIndiNodeLinker);
2249 return this;
2250 }
2251
2252 CProcessingDataBox* CProcessingDataBox::setRemainingIndividualSaturationProcessNodeLinker(CIndividualSaturationProcessNodeLinker* indiProcessNodeLinker) {
2253 mRemSatIndiNodeLinker = indiProcessNodeLinker;
2254 return this;
2255 }
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265 CIndividualSaturationSuccessorLinkDataLinker* CProcessingDataBox::getRemainingIndividualSuccessorLinkDataLinker() {
2266 return mRemSatIndiSuccLinkDataLinker;
2267 }
2268
2269 CIndividualSaturationSuccessorLinkDataLinker* CProcessingDataBox::takeRemainingIndividualSuccessorLinkDataLinker() {
2270 CIndividualSaturationSuccessorLinkDataLinker* satSuccLinkDataLinker = mRemSatIndiSuccLinkDataLinker;
2271 if (mRemSatIndiSuccLinkDataLinker) {
2272 mRemSatIndiSuccLinkDataLinker = mRemSatIndiSuccLinkDataLinker->getNext();
2273 satSuccLinkDataLinker->clearNext();
2274 }
2275 return satSuccLinkDataLinker;
2276 }
2277
2278 CProcessingDataBox* CProcessingDataBox::addRemainingIndividualSuccessorLinkDataLinker(CIndividualSaturationSuccessorLinkDataLinker* succLinkDataLinker) {
2279 mRemSatIndiSuccLinkDataLinker = succLinkDataLinker->append(mRemSatIndiSuccLinkDataLinker);
2280 return this;
2281 }
2282
2283 CProcessingDataBox* CProcessingDataBox::setRemainingIndividualSuccessorLinkDataLinker(CIndividualSaturationSuccessorLinkDataLinker* succLinkDataLinker) {
2284 mRemSatIndiSuccLinkDataLinker = succLinkDataLinker;
2285 return this;
2286 }
2287
2288
2289 bool CProcessingDataBox::hasBranchingInstruction() {
2290 return mBranchingInstruction != nullptr;
2291 }
2292
2293 CBranchingInstruction* CProcessingDataBox::getBranchingInstruction() {
2294 return mBranchingInstruction;
2295 }
2296
2297 CProcessingDataBox* CProcessingDataBox::setBranchingInstruction(CBranchingInstruction* branchingInstruction) {
2298 mBranchingInstruction = branchingInstruction;
2299 return this;
2300 }
2301
2302 CProcessingDataBox* CProcessingDataBox::clearBranchingInstruction() {
2303 mBranchingInstruction = nullptr;
2304 return this;
2305 }
2306
2307 CXLinker<cint64>* CProcessingDataBox::getLastMergedPossibleInstanceIndividualLinker() {
2308 return mLastMergedPossibleInstanceIndividualLinker;
2309 }
2310
2311 CProcessingDataBox* CProcessingDataBox::setLastMergedPossibleInstanceIndividualLinker(CXLinker<cint64>* lastMergedPossibleInstanceLinker) {
2312 mLastMergedPossibleInstanceIndividualLinker = lastMergedPossibleInstanceLinker;
2313 return this;
2314 }
2315
2316
2317
2318 CXLinker<CXLinker<cint64>*>* CProcessingDataBox::getCurrentMergedPossibleInstanceIndividualLinkersLinker() {
2319 return mCurrentMergedPossibleInstanceIndividualLinkersLinker;
2320 }
2321
2322 CProcessingDataBox* CProcessingDataBox::setCurrentMergedPossibleInstanceIndividualLinkersLinker(CXLinker<CXLinker<cint64>*>* mergedPossibleInstanceLinker) {
2323 mCurrentMergedPossibleInstanceIndividualLinkersLinker = mergedPossibleInstanceLinker;
2324 return this;
2325 }
2326
2327
2328 cint64 CProcessingDataBox::getRemainingPossibleInstanceIndividualMergingLimit() {
2329 return mRemainingPossibleInstanceIndividualMergingLimit;
2330 }
2331
2332 CProcessingDataBox* CProcessingDataBox::setRemainingPossibleInstanceIndividualMergingLimit(cint64 limit) {
2333 mRemainingPossibleInstanceIndividualMergingLimit = limit;
2334 return this;
2335 }
2336
2337
2338
2339
2340
2341 cint64 CProcessingDataBox::getPossibleInstanceIndividualMergedCount() {
2342 return mPossibleInstanceIndividualMergedCount;
2343 }
2344
2345 CProcessingDataBox* CProcessingDataBox::setPossibleInstanceIndividualMergedCount(cint64 count) {
2346 mPossibleInstanceIndividualMergedCount = count;
2347 return this;
2348 }
2349
2350
2351
2352 cint64 CProcessingDataBox::getPossibleInstanceIndividualCurrentMergingCount() {
2353 return mPossibleInstanceIndividualCurrentMergingCount;
2354 }
2355
2356 CProcessingDataBox* CProcessingDataBox::setPossibleInstanceIndividualCurrentMergingCount(cint64 count) {
2357 mPossibleInstanceIndividualCurrentMergingCount = count;
2358 return this;
2359 }
2360
2361
2362
2363
2364 cint64 CProcessingDataBox::getPossibleInstanceIndividualMergingSize() {
2365 return mPossibleInstanceIndividualMergingSize;
2366 }
2367
2368 CProcessingDataBox* CProcessingDataBox::setPossibleInstanceIndividualMergingSize(cint64 limit) {
2369 mPossibleInstanceIndividualMergingSize = limit;
2370 return this;
2371 }
2372
2373
2374
2375
2376 bool CProcessingDataBox::isPossibleInstanceIndividualMergingStopped() {
2377 return mPossibleInstanceIndividualMergingStopped;
2378 }
2379
2380 CProcessingDataBox* CProcessingDataBox::setPossibleInstanceIndividualMergingStopped(bool stopped) {
2381 mPossibleInstanceIndividualMergingStopped = stopped;
2382 return this;
2383 }
2384
2385
2386 cint64 CProcessingDataBox::getBackendCacheIntegratedIndividualNodeCount() {
2387 return mBackendCacheIntegratedIndividualNodeCount;
2388 }
2389
2390 CProcessingDataBox* CProcessingDataBox::incBackendCacheIntegratedIndividualNodeCount(cint64 count) {
2391 mBackendCacheIntegratedIndividualNodeCount += count;
2392 return this;
2393 }
2394
2395
2396
2397
2398 cint64 CProcessingDataBox::getBackendCacheIntegratedSameIndividualNodeCount() {
2399 return mBackendCacheIntegratedSameIndividualNodeCount;
2400 }
2401
2402 CProcessingDataBox* CProcessingDataBox::incBackendCacheIntegratedSameIndividualNodeCount(cint64 count) {
2403 mBackendCacheIntegratedSameIndividualNodeCount += count;
2404 return this;
2405 }
2406
2407
2408
2409 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::getLastBackendCacheIntegratedIndividualNodeLinker() {
2410 return mLastBackendCacheIntegratedIndiNodeLinker;
2411 }
2412
2413 CProcessingDataBox* CProcessingDataBox::setLastBackendCacheIntegratedIndividualNodeLinker(CXLinker<CIndividualProcessNode*>* indiLinker) {
2414 mLastBackendCacheIntegratedIndiNodeLinker = indiLinker;
2415 mBackendCacheIntegratedIndividualNodeCount = indiLinker->getCount();
2416 return this;
2417 }
2418
2419 CProcessingDataBox* CProcessingDataBox::addLastBackendCacheIntegratedIndividualNodeLinker(CXLinker<CIndividualProcessNode*>* indiLinker) {
2420 mBackendCacheIntegratedIndividualNodeCount += indiLinker->getCount();
2421 mLastBackendCacheIntegratedIndiNodeLinker = indiLinker->append(mLastBackendCacheIntegratedIndiNodeLinker);
2422 return this;
2423 }
2424
2425
2426 CProcessingDataBox* CProcessingDataBox::setBackendCacheLoadedAssociationHash(CIndividualRepresentativeBackendCacheLoadedAssociationHash* backendCacheLoadedAssociationHash) {
2427 mUseBackendLoadedAssociationHash = backendCacheLoadedAssociationHash;
2428 mLocBackendLoadedAssociationHash = backendCacheLoadedAssociationHash;
2429 return this;
2430 }
2431
2432
2433 CIndividualRepresentativeBackendCacheLoadedAssociationHash* CProcessingDataBox::getBackendCacheLoadedAssociationHash(bool createOrForceLocalisation) {
2434 if (createOrForceLocalisation && !mLocBackendLoadedAssociationHash) {
2435 mLocBackendLoadedAssociationHash = CObjectParameterizingAllocator<CIndividualRepresentativeBackendCacheLoadedAssociationHash, CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext), mProcessContext);
2436 mLocBackendLoadedAssociationHash->initIndividualRepresentativeBackendCacheLoadedAssociationHash(mUseBackendLoadedAssociationHash);
2437 mUseBackendLoadedAssociationHash = mLocBackendLoadedAssociationHash;
2438 }
2439 return mUseBackendLoadedAssociationHash;
2440 }
2441
2442
2443 CIndividualRepresentativeBackendCacheConceptSetLabelProcessingHash* CProcessingDataBox::getBackendCacheConceptSetLabelProcessingHash(bool createOrForceLocalisation) {
2444 if (createOrForceLocalisation && !mLocBackendConceptSetLabelProcessingHash) {
2445 mLocBackendConceptSetLabelProcessingHash = CObjectParameterizingAllocator<CIndividualRepresentativeBackendCacheConceptSetLabelProcessingHash, CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext), mProcessContext);
2446 mLocBackendConceptSetLabelProcessingHash->initIndividualRepresentativeBackendCacheConceptSetLabelProcessingHash(mUseBackendConceptSetLabelProcessingHash);
2447 mUseBackendConceptSetLabelProcessingHash = mLocBackendConceptSetLabelProcessingHash;
2448 }
2449 return mUseBackendConceptSetLabelProcessingHash;
2450 }
2451
2452
2453
2454
2455 CIndividualDelayedBackendInitializationProcessingQueue* CProcessingDataBox::getDelayedBackendConceptSetLabelProcessingInitializationQueue(bool create) {
2456 if (!mDelayedBackendInitProcQueue && create) {
2457 mDelayedBackendInitProcQueue = CObjectParameterizingAllocator< CIndividualDelayedBackendInitializationProcessingQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
2458 mDelayedBackendInitProcQueue->initProcessingQueue(mPrevDelayedBackendInitProcQueue);
2459 mUseDelayedBackendInitProcQueue = mDelayedBackendInitProcQueue;
2460 }
2461 return mUseDelayedBackendInitProcQueue;
2462 }
2463
2464
2465 CProcessingDataBox* CProcessingDataBox::clearDelayedBackendConceptSetLabelProcessingInitializationQueue() {
2466 mDelayedBackendInitProcQueue = nullptr;
2467 mUseDelayedBackendInitProcQueue = nullptr;
2468 mPrevDelayedBackendInitProcQueue = nullptr;
2469 return this;
2470 }
2471
2472
2473 CBackendNeighbourExpansionControllingData* CProcessingDataBox::getBackendNeighbourExpansionControllingData(bool createOrLocalize) {
2474 if (createOrLocalize && !mLocBackendNeighbourExpansionControllingData) {
2475 mLocBackendNeighbourExpansionControllingData = CObjectParameterizingAllocator<CBackendNeighbourExpansionControllingData, CProcessContext*>::allocateAndConstructAndParameterize(CContext::getMemoryAllocationManager(mProcessContext), mProcessContext);
2476 mLocBackendNeighbourExpansionControllingData->initExpansionControllingData(mUseBackendNeighbourExpansionControllingData);
2477 mUseBackendNeighbourExpansionControllingData = mLocBackendNeighbourExpansionControllingData;
2478 }
2479 return mUseBackendNeighbourExpansionControllingData;
2480 }
2481
2482
2483
2484 CBackendNeighbourExpansionQueue* CProcessingDataBox::getBackendNeighbourExpansionQueue(bool create) {
2485 if (!mBackendNeighbourExpansionQueue && create) {
2486 mBackendNeighbourExpansionQueue = CObjectParameterizingAllocator< CBackendNeighbourExpansionQueue, CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(), mProcessContext);
2487 mBackendNeighbourExpansionQueue->initBackendNeighbourExpansionQueue(mPrevBackendNeighbourExpansion);
2488 mUseBackendNeighbourExpansion = mBackendNeighbourExpansionQueue;
2489 }
2490 return mUseBackendNeighbourExpansion;
2491 }
2492
2493
2494 CProcessingDataBox* CProcessingDataBox::clearBackendNeighbourExpansionQueue() {
2495 mBackendNeighbourExpansionQueue = nullptr;
2496 mUseBackendNeighbourExpansion = nullptr;
2497 mPrevBackendNeighbourExpansion = nullptr;
2498 return this;
2499 }
2500
2501 bool CProcessingDataBox::hasBackendCacheUpdateIndividualsInitialized() {
2502 return mBackendCacheUpdateIndividualsInitialized;
2503 }
2504
2505 CProcessingDataBox* CProcessingDataBox::setBackendCacheUpdateIndividualsInitialized(bool initialized) {
2506 mBackendCacheUpdateIndividualsInitialized = initialized;
2507 return this;
2508 }
2509
2510
2511 CXLinker<CIndividualProcessNode*>* CProcessingDataBox::getRepresentativeNeighbourExpansionIndividualNodeLinker() {
2512 return mRepresentativeNeighbourExpansionIndividualNodeLinker;
2513 }
2514 CProcessingDataBox* CProcessingDataBox::addRepresentativeNeighbourExpansionIndividualNodeLinker(CXLinker<CIndividualProcessNode*>* indiLinker) {
2515 mRepresentativeNeighbourExpansionIndividualNodeLinker = indiLinker->append(mRepresentativeNeighbourExpansionIndividualNodeLinker);
2516 return this;
2517 }
2518
2519
2520
2521 }; // end namespace Process
2522
2523 }; // end namespace Kernel
2524
2525 }; // end namespace Reasoner
2526
2527 }; // end namespace Konclude