Debian Codegraph @

Source/Reasoner/Kernel/Process/CIndividualProcessNode.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 "CIndividualProcessNode.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33
34
35 CIndividualProcessNode::CIndividualProcessNode(CProcessContext* processContext) : mProcessContext(processContext) {
36
37 mMemAllocMan = CContext::getMemoryAllocationManager(mProcessContext);
38 mPrevIndividual = nullptr;
39
40 mConceptProcessingQueue = nullptr;
41 mUseConceptProcessingQueue = nullptr;
42 mPrevConceptProcessingQueue = nullptr;
43 mReapplyConLabelSet = nullptr;
44 mUseReapplyConLabelSet = nullptr;
45 mPrevReapplyConLabelSet = nullptr;
46
47 mReapplyRoleSuccHash = nullptr;
48 mUseReapplyRoleSuccHash = nullptr;
49 mPrevReapplyRoleSuccHash = nullptr;
50
51 mLastAddedLink = nullptr;
52
53 mConceptPropBindingSetHash = nullptr;
54 mUseConceptPropBindingSetHash = nullptr;
55 mPrevConceptPropBindingSetHash = nullptr;
56
57 mConceptVarBindPathSetHash = nullptr;
58 mUseConceptVarBindPathSetHash = nullptr;
59 mPrevConceptVarBindPathSetHash = nullptr;
60
61 mConceptRepPropSetHash = nullptr;
62 mUseConceptRepPropSetHash = nullptr;
63 mPrevConceptRepPropSetHash = nullptr;
64
65 mSuccRoleHash = nullptr;
66 mUseSuccRoleHash = nullptr;
67 mPrevSuccRoleHash = nullptr;
68
69 mConnSuccSet = nullptr;
70 mUseConnSuccSet = nullptr;
71 mPrevConnSuccSet = nullptr;
72
73 mDisjointSuccRoleHash = nullptr;
74 mUseDisjointSuccRoleHash = nullptr;
75 mPrevDisjointSuccRoleHash = nullptr;
76 mDisjointRoleConnections = false;
77
78
79 mDistinctHash = nullptr;
80 mUseDistinctHash = nullptr;
81 mPrevDistinctHash = nullptr;
82
83 mBackendSyncData = nullptr;
84 mPrevBackendSyncData = nullptr;
85
86 indiModel = nullptr;
87 mSatCacheRetData = nullptr;
88 mPrevSatCacheRetData = nullptr;
89 mSatCacheStoringData = nullptr;
90 mPrevSatCacheStoringData = nullptr;
91 mIndiBlock = nullptr;
92 mIndiVarPropBlockData = nullptr;
93 mPrevIndiBlock = nullptr;
94 mPrevIndiVarPropBlockData = nullptr;
95 mAncestorLink = nullptr;
96
97 mIndiSatBlockData = nullptr;
98 mPrevIndiSatBlockData = nullptr;
99
100 mIndiUnsatCacheRet = nullptr;
101 mPrevIndiUnsatCacheRet = nullptr;
102
103 mSigBlockConExpData = nullptr;
104 mPrevSigBlockConExpData = nullptr;
105
106 mReusingConExpData = nullptr;
107 mPrevReusingConExpData = nullptr;
108
109 mInitializingConceptLinkerIt = nullptr;
110 mProcessInitializingConceptLinkerIt = nullptr;
111 mAssertionConceptLinkerIt = nullptr;
112 mAssertionDataLinkerIt = nullptr;
113 mAssertedDataLiteralLinker = nullptr;
114 mLastProcessedAssertionDataLinker = nullptr;
115 mLastAssertedDataLiteralLinker = nullptr;
116 mAssertionRoleLinkerIt = nullptr;
117 mBlockedIndividualsLinker = nullptr;
118 mReverseAssertionRoleLinkerIt = nullptr;
119 mAdditionalRoleAssertionsLinker = nullptr;
120 mAdditionalDataAssertionsLinker = nullptr;
121 mLastProcessedAdditionalDataAssertionsLinker = nullptr;
122 mBaseConceptsInitialized = false;
123 mUniversallyConnectionIndividualInitialized = false;
124 mRoleAssertionsInitialized = false;
125 mReverseRoleAssertionsInitialized = false;
126 mNominalIndiTriplesAssertions = false;
127 mLoadedNominalIndiTriplesAssertions = false;
128 mLoadedNominalIndiRepresentativeBackendData = false;
129
130 mInitConceptDescriptor = nullptr;
131
132 mSatCachedAbsorbedDisjunctionsReapplyConDes = nullptr;
133 mSatCachedAbsorbedSuccessorReapplyConDes = nullptr;
134
135 mSigBlockIndExplData = nullptr;
136 mPrevSigBlockIndExplData = nullptr;
137 mUseSigBlockIndExplData = nullptr;
138
139 mSigBlockFollowSet = nullptr;
140 mUseSigBlockFollowSet = nullptr;
141 mPrevSigBlockFollowSet = nullptr;
142
143 mLastConceptCountCachedBlockerCandidate = 0;
144 mLastConceptCountSearchBlockerCandidate = 0;
145 mLastSearchBlockerCandidateCount = 0;
146 mLastSearchBlockerCandidateSignature = 0;
147 mBlockingCachingSavedCandidateCount = 0;
148
149 indiAncDepth = 0;
150 mNominalLevel = 0;
151 mMergeIntoID = 0;
152 mIndiID = 0;
153 mNomIndi = nullptr;
154 mMergedDepTrackPoint = nullptr;
155
156 mInvalidSignatureBlocking = false;
157 mProcessingQueued = false;
158 mExtendedQueueProcessing = false;
159 mImmediatelyProcessingQueued = false;
160 mDetExpProcessingQueued = false;
161 mDepthProcessingQueued = false;
162 mBlockedReactProcessingQueued = false;
163 mDelayedNominalProcessingQueued = false;
164 mNominalProcessingDelayingChecked = false;
165 mBackendSynchronRetestProcessingQueued = false;
166 mBackendIndirectCompatibilityExpansionQueued = false;
167 mBackendDirectInfluenceExpansionQueued = false;
168 mBackendReuseExpansionQueued = false;
169 mBackendNeighbourExpansionQueued = false;
170 mIncrementalCompatibilityCheckingQueued = false;
171 mIncrementalExpansionQueued = false;
172
173 mAssertionInitialisationSignatureValue = 0;
174
175 mProcessingBlockedIndi = nullptr;
176 mProcessingBlockedIndividualsLinker = nullptr;
177 mSuccessorIndiNodeBackwardDependencyLinker = nullptr;
178 mBackwardDependencyToAncestorIndividualNode = false;
179 mIndiType = BLOCKABLEINDIVIDUALTYPE;
180
181 mProcessingRestrictionFlags = 0;
182
183 mRoleBackPropHash = nullptr;
184 mIndiProcessLinker = nullptr;
185 mConceptProcessLinker = nullptr;
186 mRequiredBackProp = false;
187 mSubstituteIndiNode = nullptr;
188 setLocalizationTag(mProcessContext->getUsedProcessTagger());
189
190 mDebugBlockerLastConceptDes = nullptr;
191 mCachingLossNodeReactivationInstalled = false;
192
193 mLocReactivationData = nullptr;
194 mUseReactivationData = nullptr;
195
196 mLocNominalConnectionSet = nullptr;
197 mUseNominalConnectionSet = nullptr;
198 mUseDatatypesValueSpaceData = nullptr;
199 mUseIncExpData = nullptr;
200 mIncExpID = 0;
201 mBlockerIndiNode = nullptr;
202 mFollowingIndiNode = nullptr;
203 mLocDatatypesValueSpaceData = nullptr;
204 mLocIncExpData = nullptr;
205 mLocIndividualMergingHash = nullptr;
206 mUseIndividualMergingHash = nullptr;
207 mRoleAssertionCreationID = 0;
208 mLastMergedIntoIndividualNode = nullptr;
209
210 mLocSuccIndiATMOSTReactivationData = nullptr;
211 mUseSuccIndiATMOSTReactivationData = nullptr;
212 }
213
214
215 CIndividualProcessNode* CIndividualProcessNode::initIndividualProcessNode(CIndividualProcessNode* prevIndividual) {
216 mRoleBackPropHash = nullptr;
217 mIndiProcessLinker = nullptr;
218 mConceptProcessLinker = nullptr;
219 mRequiredBackProp = false;
220 mIndiBlock = nullptr;
221 mIndiVarPropBlockData = nullptr;
222 mSubstituteIndiNode = nullptr;
223 mLocReactivationData = nullptr;
224 mLocNominalConnectionSet = nullptr;
225 mLocSuccIndiATMOSTReactivationData = nullptr;
226 mLocDatatypesValueSpaceData = nullptr;
227 mLocIncExpData = nullptr;
228 mLocIndividualMergingHash = nullptr;
229 mBackendSyncData = nullptr;
230 setBlockedTestTag(prevIndividual->getBlockedTestTag());
231 mPrevIndividual = prevIndividual;
232 mDebugBlockerLastConceptDes = prevIndividual->mDebugBlockerLastConceptDes;
233 mPrevConceptProcessingQueue = prevIndividual->mUseConceptProcessingQueue;
234 mUseConceptProcessingQueue = mPrevConceptProcessingQueue;
235 mPrevReapplyConLabelSet = prevIndividual->mUseReapplyConLabelSet;
236 mUseReapplyConLabelSet = mPrevReapplyConLabelSet;
237 mPrevReapplyRoleSuccHash = prevIndividual->mUseReapplyRoleSuccHash;
238 mUseReapplyRoleSuccHash = mPrevReapplyRoleSuccHash;
239 mLastAddedLink = prevIndividual->mLastAddedLink;
240 mPrevConceptPropBindingSetHash = prevIndividual->mUseConceptPropBindingSetHash;
241 mUseConceptPropBindingSetHash = mPrevConceptPropBindingSetHash;
242 mPrevConceptVarBindPathSetHash = prevIndividual->mUseConceptVarBindPathSetHash;
243 mUseConceptVarBindPathSetHash = mPrevConceptVarBindPathSetHash;
244 mPrevConceptRepPropSetHash = prevIndividual->mUseConceptRepPropSetHash;
245 mUseConceptRepPropSetHash = mPrevConceptRepPropSetHash;
246 mPrevSuccRoleHash = prevIndividual->mUseSuccRoleHash;
247 mUseSuccRoleHash = mPrevSuccRoleHash;
248 mPrevDisjointSuccRoleHash = prevIndividual->mUseDisjointSuccRoleHash;
249 mUseDisjointSuccRoleHash = mPrevDisjointSuccRoleHash;
250 mDisjointRoleConnections = prevIndividual->mDisjointRoleConnections;
251 mPrevConnSuccSet = prevIndividual->mUseConnSuccSet;
252 mUseConnSuccSet = mPrevConnSuccSet;
253 mPrevDistinctHash = prevIndividual->mUseDistinctHash;
254 mUseDistinctHash = mPrevDistinctHash;
255 mInitializingConceptLinkerIt = prevIndividual->mInitializingConceptLinkerIt;
256 mProcessInitializingConceptLinkerIt = prevIndividual->mProcessInitializingConceptLinkerIt;
257 mAssertionRoleLinkerIt = prevIndividual->mAssertionRoleLinkerIt;
258 mAssertionConceptLinkerIt = prevIndividual->mAssertionConceptLinkerIt;
259 mAssertionDataLinkerIt = prevIndividual->mAssertionDataLinkerIt;
260 mAssertedDataLiteralLinker = prevIndividual->mAssertedDataLiteralLinker;
261 mLastProcessedAssertionDataLinker = prevIndividual->mLastProcessedAssertionDataLinker;
262 mLastAssertedDataLiteralLinker = prevIndividual->mLastAssertedDataLiteralLinker;
263 mReverseAssertionRoleLinkerIt = prevIndividual->mReverseAssertionRoleLinkerIt;
264 mAdditionalRoleAssertionsLinker = prevIndividual->mAdditionalRoleAssertionsLinker;
265 mAdditionalDataAssertionsLinker = prevIndividual->mAdditionalDataAssertionsLinker;
266 mLastProcessedAdditionalDataAssertionsLinker = prevIndividual->mLastProcessedAdditionalDataAssertionsLinker;
267 mBaseConceptsInitialized = prevIndividual->mBaseConceptsInitialized;
268 mUniversallyConnectionIndividualInitialized = prevIndividual->mUniversallyConnectionIndividualInitialized;
269 mRoleAssertionsInitialized = prevIndividual->mRoleAssertionsInitialized;
270 mReverseRoleAssertionsInitialized = prevIndividual->mReverseRoleAssertionsInitialized;
271 mLoadedNominalIndiTriplesAssertions = prevIndividual->mLoadedNominalIndiTriplesAssertions;
272 mLoadedNominalIndiRepresentativeBackendData = prevIndividual->mLoadedNominalIndiRepresentativeBackendData;
273 mNominalIndiTriplesAssertions = prevIndividual->mNominalIndiTriplesAssertions;
274 mBlockedIndividualsLinker = prevIndividual->mBlockedIndividualsLinker;
275 mSuccessorIndiNodeBackwardDependencyLinker = prevIndividual->mSuccessorIndiNodeBackwardDependencyLinker;
276 mBackwardDependencyToAncestorIndividualNode = prevIndividual->mBackwardDependencyToAncestorIndividualNode;
277 mAncestorLink = prevIndividual->mAncestorLink;
278 indiModel = prevIndividual->indiModel;
279 mPrevIndiBlock = prevIndividual->mPrevIndiBlock;
280 mPrevIndiVarPropBlockData = prevIndividual->mPrevIndiVarPropBlockData;
281 mPrevIndiSatBlockData = prevIndividual->mPrevIndiSatBlockData;
282 mPrevIndiUnsatCacheRet = prevIndividual->mPrevIndiUnsatCacheRet;
283 mPrevSigBlockConExpData = prevIndividual->mPrevSigBlockConExpData;
284 mPrevReusingConExpData = prevIndividual->mPrevReusingConExpData;
285 mPrevSatCacheRetData = prevIndividual->mPrevSatCacheRetData;
286 mPrevBackendSyncData = prevIndividual->mPrevBackendSyncData;
287 mPrevSigBlockIndExplData = prevIndividual->mUseSigBlockIndExplData;
288 mUseSigBlockIndExplData = mPrevSigBlockIndExplData;
289 mPrevSigBlockFollowSet = prevIndividual->mUseSigBlockFollowSet;
290 mUseSigBlockFollowSet = mPrevSigBlockFollowSet;
291 mPrevSatCacheStoringData = prevIndividual->mPrevSatCacheStoringData;
292 indiAncDepth = prevIndividual->indiAncDepth;
293 mNominalLevel = prevIndividual->mNominalLevel;
294 mMergeIntoID = prevIndividual->mMergeIntoID;
295 mMergedDepTrackPoint = prevIndividual->mMergedDepTrackPoint;
296 mIndiID = prevIndividual->mIndiID;
297 mIndiType = prevIndividual->mIndiType;
298 mProcessingBlockedIndi = prevIndividual->mProcessingBlockedIndi;
299 mProcessingBlockedIndividualsLinker = prevIndividual->mProcessingBlockedIndividualsLinker;
300 mInitConceptDescriptor = prevIndividual->mInitConceptDescriptor;
301 mProcessingRestrictionFlags = prevIndividual->mProcessingRestrictionFlags;
302 mNomIndi = prevIndividual->mNomIndi;
303 mInvalidSignatureBlocking = prevIndividual->mInvalidSignatureBlocking;
304 mProcessingQueued = prevIndividual->mProcessingQueued;
305 mExtendedQueueProcessing = prevIndividual->mExtendedQueueProcessing;
306 mImmediatelyProcessingQueued = prevIndividual->mImmediatelyProcessingQueued;
307 mDetExpProcessingQueued = prevIndividual->mDetExpProcessingQueued;
308 mDepthProcessingQueued = prevIndividual->mDepthProcessingQueued;
309 mBlockedReactProcessingQueued = prevIndividual->mBlockedReactProcessingQueued;
310 mBackendSynchronRetestProcessingQueued = prevIndividual->mBackendSynchronRetestProcessingQueued;
311 mBackendDirectInfluenceExpansionQueued = prevIndividual->mBackendDirectInfluenceExpansionQueued;
312 mBackendIndirectCompatibilityExpansionQueued = prevIndividual->mBackendIndirectCompatibilityExpansionQueued;
313 mBackendReuseExpansionQueued = prevIndividual->mBackendReuseExpansionQueued;
314 mBackendNeighbourExpansionQueued = prevIndividual->mBackendNeighbourExpansionQueued;
315 mIncrementalCompatibilityCheckingQueued = prevIndividual->mIncrementalCompatibilityCheckingQueued;
316 mIncrementalExpansionQueued = prevIndividual->mIncrementalExpansionQueued;
317 mDelayedNominalProcessingQueued = prevIndividual->mDelayedNominalProcessingQueued;
318 mNominalProcessingDelayingChecked = prevIndividual->mNominalProcessingDelayingChecked;
319 mAssertionInitialisationSignatureValue = prevIndividual->mAssertionInitialisationSignatureValue;
320 mLastProcessingPriority = prevIndividual->mLastProcessingPriority;
321 mDependencyTrackPoint = prevIndividual->mDependencyTrackPoint;
322 mSatCachedAbsorbedDisjunctionsReapplyConDes = prevIndividual->mSatCachedAbsorbedDisjunctionsReapplyConDes;
323 mSatCachedAbsorbedSuccessorReapplyConDes = prevIndividual->mSatCachedAbsorbedSuccessorReapplyConDes;
324 mLastConceptCountCachedBlockerCandidate = prevIndividual->mLastConceptCountCachedBlockerCandidate;
325 mLastConceptCountSearchBlockerCandidate = prevIndividual->mLastConceptCountSearchBlockerCandidate;
326 mBlockingCachingSavedCandidateCount = prevIndividual->mBlockingCachingSavedCandidateCount;
327 mLastSearchBlockerCandidateCount = prevIndividual->mLastSearchBlockerCandidateCount;
328 mLastSearchBlockerCandidateSignature = prevIndividual->mLastSearchBlockerCandidateSignature;
329 mCachingLossNodeReactivationInstalled = prevIndividual->mCachingLossNodeReactivationInstalled;
330 prevIndividual->setRelocalized();
331 mUseReactivationData = prevIndividual->mUseReactivationData;
332 mUseNominalConnectionSet = prevIndividual->mUseNominalConnectionSet;
333 mUseSuccIndiATMOSTReactivationData = prevIndividual->mUseSuccIndiATMOSTReactivationData;
334 mUseDatatypesValueSpaceData = prevIndividual->mUseDatatypesValueSpaceData;
335 mUseIncExpData = prevIndividual->mUseIncExpData;
336 mIncExpID = prevIndividual->mIncExpID;
337 mRoleAssertionCreationID = prevIndividual->mRoleAssertionCreationID;
338 mUseIndividualMergingHash = prevIndividual->mUseIndividualMergingHash;
339 mBlockerIndiNode = prevIndividual->mBlockerIndiNode;
340 mFollowingIndiNode = prevIndividual->mFollowingIndiNode;
341 mLastMergedIntoIndividualNode = prevIndividual->mLastMergedIntoIndividualNode;
342 return this;
343 }
344
345
346 CIndividualProcessNode* CIndividualProcessNode::initIndividualProcessNodeCopy(CIndividualProcessNode* prevIndividual, bool adobtConceptLabels, bool adobtRoleSuccessors, bool adobtStatus) {
347 mRoleBackPropHash = nullptr;
348 mIndiProcessLinker = nullptr;
349 mConceptProcessLinker = nullptr;
350 mRequiredBackProp = false;
351 mSubstituteIndiNode = nullptr;
352 mIndiBlock = nullptr;
353 mIndiVarPropBlockData = nullptr;
354 mLocReactivationData = nullptr;
355 mLocNominalConnectionSet = nullptr;
356 mLocDatatypesValueSpaceData = nullptr;
357 mLocIncExpData = nullptr;
358 mLocIndividualMergingHash = nullptr;
359 prevIndividual->setRelocalized();
360 if (adobtStatus) {
361 setBlockedTestTag(prevIndividual->getBlockedTestTag());
362 }
363 mBackendSyncData = nullptr;
364 mPrevIndividual = prevIndividual;
365 mPrevConceptProcessingQueue = prevIndividual->mUseConceptProcessingQueue;
366 mUseConceptProcessingQueue = mPrevConceptProcessingQueue;
367 mDependencyTrackPoint = prevIndividual->mDependencyTrackPoint;
368 mDebugBlockerLastConceptDes = prevIndividual->mDebugBlockerLastConceptDes;
369 mCachingLossNodeReactivationInstalled = prevIndividual->mCachingLossNodeReactivationInstalled;
370 mLastMergedIntoIndividualNode = prevIndividual->mLastMergedIntoIndividualNode;
371
372 if (adobtConceptLabels) {
373 mPrevReapplyConLabelSet = prevIndividual->mUseReapplyConLabelSet;
374 mUseReapplyConLabelSet = mPrevReapplyConLabelSet;
375 }
376 if (adobtRoleSuccessors) {
377 mPrevReapplyRoleSuccHash = prevIndividual->mUseReapplyRoleSuccHash;
378 mUseReapplyRoleSuccHash = mPrevReapplyRoleSuccHash;
379 mLastAddedLink = prevIndividual->mLastAddedLink;
380 mPrevConceptPropBindingSetHash = prevIndividual->mUseConceptPropBindingSetHash;
381 mUseConceptPropBindingSetHash = mPrevConceptPropBindingSetHash;
382 mPrevConceptVarBindPathSetHash = prevIndividual->mUseConceptVarBindPathSetHash;
383 mUseConceptVarBindPathSetHash = mPrevConceptVarBindPathSetHash;
384 mPrevConceptRepPropSetHash = prevIndividual->mUseConceptRepPropSetHash;
385 mUseConceptRepPropSetHash = mPrevConceptRepPropSetHash;
386 mPrevSuccRoleHash = prevIndividual->mUseSuccRoleHash;
387 mUseSuccRoleHash = mPrevSuccRoleHash;
388 mPrevDisjointSuccRoleHash = prevIndividual->mUseDisjointSuccRoleHash;
389 mUseDisjointSuccRoleHash = mPrevDisjointSuccRoleHash;
390 mDisjointRoleConnections = prevIndividual->mDisjointRoleConnections;
391 mPrevConnSuccSet = prevIndividual->mUseConnSuccSet;
392 mUseConnSuccSet = mPrevConnSuccSet;
393 mPrevDistinctHash = prevIndividual->mUseDistinctHash;
394 mUseDistinctHash = mPrevDistinctHash;
395 mUseReactivationData = prevIndividual->mUseReactivationData;
396 mUseNominalConnectionSet = prevIndividual->mUseNominalConnectionSet;
397 mUseSuccIndiATMOSTReactivationData = prevIndividual->mUseSuccIndiATMOSTReactivationData;
398 mNominalProcessingDelayingChecked = prevIndividual->mNominalProcessingDelayingChecked;
399 mUseDatatypesValueSpaceData = prevIndividual->mUseDatatypesValueSpaceData;
400 mUseIndividualMergingHash = prevIndividual->mUseIndividualMergingHash;
401 }
402 if (adobtStatus) {
403 mRoleAssertionCreationID = prevIndividual->mRoleAssertionCreationID;
404 mIncExpID = prevIndividual->mIncExpID;
405 mUseIncExpData = prevIndividual->mUseIncExpData;
406 mFollowingIndiNode = prevIndividual->mFollowingIndiNode;
407 mBlockerIndiNode = prevIndividual->mBlockerIndiNode;
408 mInitializingConceptLinkerIt = prevIndividual->mInitializingConceptLinkerIt;
409 mProcessInitializingConceptLinkerIt = prevIndividual->mProcessInitializingConceptLinkerIt;
410 mAssertionRoleLinkerIt = prevIndividual->mAssertionRoleLinkerIt;
411 mAssertionConceptLinkerIt = prevIndividual->mAssertionConceptLinkerIt;
412 mAssertionDataLinkerIt = prevIndividual->mAssertionDataLinkerIt;
413 mAssertedDataLiteralLinker = prevIndividual->mAssertedDataLiteralLinker;
414 mLastProcessedAssertionDataLinker = prevIndividual->mLastProcessedAssertionDataLinker;
415 mLastAssertedDataLiteralLinker = prevIndividual->mLastAssertedDataLiteralLinker;
416 mReverseAssertionRoleLinkerIt = prevIndividual->mReverseAssertionRoleLinkerIt;
417 mAdditionalRoleAssertionsLinker = prevIndividual->mAdditionalRoleAssertionsLinker;
418 mAdditionalDataAssertionsLinker = prevIndividual->mAdditionalDataAssertionsLinker;
419 mLastProcessedAdditionalDataAssertionsLinker = prevIndividual->mLastProcessedAdditionalDataAssertionsLinker;
420 mBaseConceptsInitialized = prevIndividual->mBaseConceptsInitialized;
421 mUniversallyConnectionIndividualInitialized = prevIndividual->mUniversallyConnectionIndividualInitialized;
422 mRoleAssertionsInitialized = prevIndividual->mRoleAssertionsInitialized;
423 mReverseRoleAssertionsInitialized = prevIndividual->mReverseRoleAssertionsInitialized;
424 mNominalIndiTriplesAssertions = prevIndividual->mNominalIndiTriplesAssertions;
425 mLoadedNominalIndiTriplesAssertions = prevIndividual->mLoadedNominalIndiTriplesAssertions;
426 mLoadedNominalIndiRepresentativeBackendData = prevIndividual->mLoadedNominalIndiRepresentativeBackendData;
427 mBlockedIndividualsLinker = prevIndividual->mBlockedIndividualsLinker;
428 mSuccessorIndiNodeBackwardDependencyLinker = prevIndividual->mSuccessorIndiNodeBackwardDependencyLinker;
429 mBackwardDependencyToAncestorIndividualNode = prevIndividual->mBackwardDependencyToAncestorIndividualNode;
430 mAncestorLink = prevIndividual->mAncestorLink;
431 indiModel = prevIndividual->indiModel;
432 mPrevIndiBlock = prevIndividual->mPrevIndiBlock;
433 mPrevIndiVarPropBlockData = prevIndividual->mPrevIndiVarPropBlockData;
434 mPrevIndiSatBlockData = prevIndividual->mPrevIndiSatBlockData;
435 mPrevIndiUnsatCacheRet = prevIndividual->mPrevIndiUnsatCacheRet;
436 mPrevSigBlockConExpData = prevIndividual->mPrevSigBlockConExpData;
437 mPrevReusingConExpData = prevIndividual->mPrevReusingConExpData;
438 mPrevSatCacheRetData = prevIndividual->mPrevSatCacheRetData;
439 mPrevBackendSyncData = prevIndividual->mPrevBackendSyncData;
440 mPrevSigBlockIndExplData = prevIndividual->mUseSigBlockIndExplData;
441 mUseSigBlockIndExplData = mPrevSigBlockIndExplData;
442 mPrevSigBlockFollowSet = prevIndividual->mUseSigBlockFollowSet;
443 mUseSigBlockFollowSet = mPrevSigBlockFollowSet;
444 mPrevSatCacheStoringData = prevIndividual->mPrevSatCacheStoringData;
445 mProcessingBlockedIndi = prevIndividual->mProcessingBlockedIndi;
446 mProcessingBlockedIndividualsLinker = prevIndividual->mProcessingBlockedIndividualsLinker;
447 mInitConceptDescriptor = prevIndividual->mInitConceptDescriptor;
448 mProcessingRestrictionFlags = prevIndividual->mProcessingRestrictionFlags;
449 mIndiID = prevIndividual->mIndiID;
450 mMergeIntoID = prevIndividual->mMergeIntoID;
451 mMergedDepTrackPoint = prevIndividual->mMergedDepTrackPoint;
452 mNomIndi = prevIndividual->mNomIndi;
453 mSatCachedAbsorbedDisjunctionsReapplyConDes = prevIndividual->mSatCachedAbsorbedDisjunctionsReapplyConDes;
454 mSatCachedAbsorbedSuccessorReapplyConDes = prevIndividual->mSatCachedAbsorbedSuccessorReapplyConDes;
455 mLastConceptCountCachedBlockerCandidate = prevIndividual->mLastConceptCountCachedBlockerCandidate;
456 mLastConceptCountSearchBlockerCandidate = prevIndividual->mLastConceptCountSearchBlockerCandidate;
457 mBlockingCachingSavedCandidateCount = prevIndividual->mBlockingCachingSavedCandidateCount;
458 mLastSearchBlockerCandidateCount = prevIndividual->mLastSearchBlockerCandidateCount;
459 mLastSearchBlockerCandidateSignature = prevIndividual->mLastSearchBlockerCandidateSignature;
460 mInvalidSignatureBlocking = prevIndividual->mInvalidSignatureBlocking;
461 mProcessingQueued = prevIndividual->mProcessingQueued;
462 mExtendedQueueProcessing = prevIndividual->mExtendedQueueProcessing;
463 mLastProcessingPriority = prevIndividual->mLastProcessingPriority;
464 mImmediatelyProcessingQueued = prevIndividual->mImmediatelyProcessingQueued;
465 mDetExpProcessingQueued = prevIndividual->mDetExpProcessingQueued;
466 mDepthProcessingQueued = prevIndividual->mDepthProcessingQueued;
467 mBlockedReactProcessingQueued = prevIndividual->mBlockedReactProcessingQueued;
468 mBackendSynchronRetestProcessingQueued = prevIndividual->mBackendSynchronRetestProcessingQueued;
469 mBackendIndirectCompatibilityExpansionQueued = prevIndividual->mBackendIndirectCompatibilityExpansionQueued;
470 mBackendDirectInfluenceExpansionQueued = prevIndividual->mBackendDirectInfluenceExpansionQueued;
471 mBackendReuseExpansionQueued = prevIndividual->mBackendReuseExpansionQueued;
472 mBackendNeighbourExpansionQueued = prevIndividual->mBackendNeighbourExpansionQueued;
473 mIncrementalCompatibilityCheckingQueued = prevIndividual->mIncrementalCompatibilityCheckingQueued;
474 mIncrementalExpansionQueued = prevIndividual->mIncrementalExpansionQueued;
475 mDelayedNominalProcessingQueued = prevIndividual->mDelayedNominalProcessingQueued;
476 mAssertionInitialisationSignatureValue = prevIndividual->mAssertionInitialisationSignatureValue;
477 }
478 indiAncDepth = prevIndividual->indiAncDepth;
479 mNominalLevel = prevIndividual->mNominalLevel;
480 mIndiType = prevIndividual->mIndiType;
481 return this;
482 }
483
484
485
486 CIndividualProcessNode* CIndividualProcessNode::getProcessingBlockTestIndividual() {
487 return mProcessingBlockedIndi;
488 }
489
490 CIndividualProcessNode* CIndividualProcessNode::clearProcessingBlockTestIndividual() {
491 mProcessingBlockedIndi = nullptr;
492 return this;
493 }
494
495
496 CIndividualProcessNode* CIndividualProcessNode::setProcessingBlockTestIndividual(CIndividualProcessNode* processingBlockTestIndi) {
497 mProcessingBlockedIndi = processingBlockTestIndi;
498 return this;
499 }
500
501
502 bool CIndividualProcessNode::hasInitializingConcepts() {
503 return mInitializingConceptLinkerIt != nullptr;
504 }
505
506 CIndividualProcessNode* CIndividualProcessNode::clearProcessInitializingConcepts() {
507 mProcessInitializingConceptLinkerIt = nullptr;
508 return this;
509 }
510
511
512 CXSortedNegLinker<CConcept*>* CIndividualProcessNode::getProcessInitializingConceptLinker() {
513 return mProcessInitializingConceptLinkerIt;
514 }
515
516 CXSortedNegLinker<CConcept*>* CIndividualProcessNode::getInitializingConceptLinker() {
517 return mInitializingConceptLinkerIt;
518 }
519
520 CIndividualProcessNode* CIndividualProcessNode::setInitializingConceptLinker(CXSortedNegLinker<CConcept*>* initializingConceptLinkerIt) {
521 mInitializingConceptLinkerIt = initializingConceptLinkerIt;
522 return this;
523 }
524
525 CIndividualProcessNode* CIndividualProcessNode::addInitializingConceptLinker(CXSortedNegLinker<CConcept*>* initializingConceptLinkerIt) {
526 if (initializingConceptLinkerIt) {
527 mInitializingConceptLinkerIt = initializingConceptLinkerIt->append(mInitializingConceptLinkerIt);
528 mProcessInitializingConceptLinkerIt = mInitializingConceptLinkerIt;
529 }
530 return this;
531 }
532
533 bool CIndividualProcessNode::hasAssertionConcepts() {
534 return mAssertionConceptLinkerIt != nullptr;
535 }
536
537 CIndividualProcessNode* CIndividualProcessNode::clearAssertionConcepts() {
538 mAssertionConceptLinkerIt = nullptr;
539 return this;
540 }
541
542
543 CConceptAssertionLinker* CIndividualProcessNode::getAssertionConceptLinker() {
544 return mAssertionConceptLinkerIt;
545 }
546
547 CIndividualProcessNode* CIndividualProcessNode::setAssertionConceptLinker(CConceptAssertionLinker* assertionConceptLinkerIt) {
548 mAssertionConceptLinkerIt = assertionConceptLinkerIt;
549 return this;
550 }
551
552
553
554
555
556 bool CIndividualProcessNode::hasAssertionData() {
557 return mAssertionDataLinkerIt != nullptr;
558 }
559
560 CIndividualProcessNode* CIndividualProcessNode::clearAssertionData() {
561 mAssertionDataLinkerIt = nullptr;
562 return this;
563 }
564
565
566 CDataAssertionLinker* CIndividualProcessNode::getAssertionDataLinker() {
567 return mAssertionDataLinkerIt;
568 }
569
570 CIndividualProcessNode* CIndividualProcessNode::setAssertionDataLinker(CDataAssertionLinker* assertionDataLinkerIt) {
571 mAssertionDataLinkerIt = assertionDataLinkerIt;
572 return this;
573 }
574
575
576
577 bool CIndividualProcessNode::hasAssertedDataLiterals() {
578 return mAssertedDataLiteralLinker != nullptr;
579 }
580
581 CProcessAssertedDataLiteralLinker* CIndividualProcessNode::getAssertedDataLiteralLinker() {
582 return mAssertedDataLiteralLinker;
583 }
584
585 CIndividualProcessNode* CIndividualProcessNode::setAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker) {
586 mAssertedDataLiteralLinker = dataLiteralLinker;
587 return this;
588 }
589
590
591
592 CDataAssertionLinker* CIndividualProcessNode::getLastProcessedAssertionDataLinker() {
593 return mLastProcessedAssertionDataLinker;
594 }
595
596 CIndividualProcessNode* CIndividualProcessNode::setLastProcessedAssertionDataLinker(CDataAssertionLinker* dataLiteralLinker) {
597 mLastProcessedAssertionDataLinker = dataLiteralLinker;
598 return this;
599 }
600
601
602
603 CProcessAssertedDataLiteralLinker* CIndividualProcessNode::getLastAssertedDataLiteralLinker() {
604 return mLastAssertedDataLiteralLinker;
605 }
606
607 CIndividualProcessNode* CIndividualProcessNode::setLastAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker) {
608 mLastAssertedDataLiteralLinker = dataLiteralLinker;
609 return this;
610 }
611
612 CIndividualProcessNode* CIndividualProcessNode::addAssertedDataLiteralLinker(CProcessAssertedDataLiteralLinker* dataLiteralLinker) {
613 mAssertedDataLiteralLinker = dataLiteralLinker->append(mAssertedDataLiteralLinker);
614 return this;
615 }
616
617
618 CIndividualProcessNode* CIndividualProcessNode::clearAssertedDataLiterals() {
619 mAssertedDataLiteralLinker = nullptr;
620 return this;
621 }
622
623
624
625
626 bool CIndividualProcessNode::hasAssertionRoles() {
627 return mAssertionRoleLinkerIt != nullptr;
628 }
629
630 CIndividualProcessNode* CIndividualProcessNode::clearAssertionRoles() {
631 mAssertionRoleLinkerIt = nullptr;
632 return this;
633 }
634
635 CRoleAssertionLinker* CIndividualProcessNode::getAssertionRoleLinker() {
636 return mAssertionRoleLinkerIt;
637 }
638
639 CIndividualProcessNode* CIndividualProcessNode::setAssertionRoleLinker(CRoleAssertionLinker* assertionRoleLinkerIt) {
640 mAssertionRoleLinkerIt = assertionRoleLinkerIt;
641 return this;
642 }
643
644
645
646 cint64 CIndividualProcessNode::getRoleAssertionCreationID() {
647 return mRoleAssertionCreationID;
648 }
649
650 CIndividualProcessNode* CIndividualProcessNode::setRoleAssertionCreationID(cint64 creationID) {
651 mRoleAssertionCreationID = creationID;
652 return this;
653 }
654
655
656
657 bool CIndividualProcessNode::hasReverseAssertionRoles() {
658 return mReverseAssertionRoleLinkerIt != nullptr;
659 }
660
661 CIndividualProcessNode* CIndividualProcessNode::clearReverseAssertionRoles() {
662 mReverseAssertionRoleLinkerIt = nullptr;
663 return this;
664 }
665
666 CReverseRoleAssertionLinker* CIndividualProcessNode::getReverseAssertionRoleLinker() {
667 return mReverseAssertionRoleLinkerIt;
668 }
669
670 CIndividualProcessNode* CIndividualProcessNode::setReverseAssertionRoleLinker(CReverseRoleAssertionLinker* reverseAssertionRoleLinkerIt) {
671 mReverseAssertionRoleLinkerIt = reverseAssertionRoleLinkerIt;
672 return this;
673 }
674
675
676
677
678
679
680
681
682 bool CIndividualProcessNode::hasAdditionalRoleAssertionsLinker() {
683 return mAdditionalRoleAssertionsLinker != nullptr;
684 }
685
686 CIndividualProcessNode* CIndividualProcessNode::clearAdditionalRoleAssertionsLinker() {
687 mAdditionalRoleAssertionsLinker = nullptr;
688 return this;
689 }
690
691 CAdditionalProcessRoleAssertionsLinker* CIndividualProcessNode::getAdditionalRoleAssertionsLinker() {
692 return mAdditionalRoleAssertionsLinker;
693 }
694
695 CIndividualProcessNode* CIndividualProcessNode::setAdditionalRoleAssertionsLinker(CAdditionalProcessRoleAssertionsLinker* reverseRoleAssertionsLinker) {
696 mAdditionalRoleAssertionsLinker = reverseRoleAssertionsLinker;
697 return this;
698 }
699
700 CIndividualProcessNode* CIndividualProcessNode::addAdditionalRoleAssertionsLinker(CAdditionalProcessRoleAssertionsLinker* reverseRoleAssertionsLinker) {
701 mAdditionalRoleAssertionsLinker = reverseRoleAssertionsLinker->append(mAdditionalRoleAssertionsLinker);
702 return this;
703 }
704
705
706
707
708
709 bool CIndividualProcessNode::hasAdditionalDataAssertionsLinker() {
710 return mAdditionalDataAssertionsLinker != nullptr;
711 }
712
713 CIndividualProcessNode* CIndividualProcessNode::clearAdditionalDataAssertionsLinker() {
714 mAdditionalDataAssertionsLinker = nullptr;
715 return this;
716 }
717
718 CAdditionalProcessDataAssertionsLinker* CIndividualProcessNode::getAdditionalDataAssertionsLinker() {
719 return mAdditionalDataAssertionsLinker;
720 }
721
722 CIndividualProcessNode* CIndividualProcessNode::setAdditionalDataAssertionsLinker(CAdditionalProcessDataAssertionsLinker* addDataAssertionsLinker) {
723 mAdditionalDataAssertionsLinker = addDataAssertionsLinker;
724 return this;
725 }
726
727 CIndividualProcessNode* CIndividualProcessNode::addAdditionalDataAssertionsLinker(CAdditionalProcessDataAssertionsLinker* addDataAssertionsLinker) {
728 mAdditionalDataAssertionsLinker = addDataAssertionsLinker->append(mAdditionalDataAssertionsLinker);
729 return this;
730 }
731
732
733 CAdditionalProcessDataAssertionsLinker* CIndividualProcessNode::getLastProcessedAdditionalDataAssertionLinker() {
734 return mLastProcessedAdditionalDataAssertionsLinker;
735 }
736
737 CIndividualProcessNode* CIndividualProcessNode::setLastProcessedAdditionalDataAssertionLinker(CAdditionalProcessDataAssertionsLinker* dataLiteralLinker) {
738 mLastProcessedAdditionalDataAssertionsLinker = dataLiteralLinker;
739 return this;
740 }
741
742
743
744
745 bool CIndividualProcessNode::hasBaseConceptsInitialized() {
746 return mBaseConceptsInitialized;
747 }
748
749 CIndividualProcessNode* CIndividualProcessNode::setBaseConceptsInitialized(bool initialized) {
750 mBaseConceptsInitialized = initialized;
751 return this;
752 }
753
754
755
756 bool CIndividualProcessNode::hasUniversallyConnectionIndividualInitialized() {
757 return mUniversallyConnectionIndividualInitialized;
758 }
759
760 CIndividualProcessNode* CIndividualProcessNode::setUniversallyConnectionIndividualInitialized(bool initialized) {
761 mUniversallyConnectionIndividualInitialized = initialized;
762 return this;
763 }
764
765
766 bool CIndividualProcessNode::hasRoleAssertionsInitialized() {
767 return mRoleAssertionsInitialized;
768 }
769
770 CIndividualProcessNode* CIndividualProcessNode::setRoleAssertionsInitialized(bool initialized) {
771 mRoleAssertionsInitialized = initialized;
772 return this;
773 }
774
775
776
777 bool CIndividualProcessNode::hasReverseRoleAssertionsInitialized() {
778 return mReverseRoleAssertionsInitialized;
779 }
780
781 CIndividualProcessNode* CIndividualProcessNode::setReverseRoleAssertionsInitialized(bool initialized) {
782 mReverseRoleAssertionsInitialized = initialized;
783 return this;
784 }
785
786
787
788 bool CIndividualProcessNode::hasNominalIndividualTriplesAssertions() {
789 return mNominalIndiTriplesAssertions;
790 }
791
792 CIndividualProcessNode* CIndividualProcessNode::setNominalIndividualTriplesAssertions(bool hasNominalAssertions) {
793 mNominalIndiTriplesAssertions = hasNominalAssertions;
794 return this;
795 }
796
797 bool CIndividualProcessNode::areNominalIndividualTriplesAssertionsLoaded() {
798 return mLoadedNominalIndiTriplesAssertions;
799 }
800
801 CIndividualProcessNode* CIndividualProcessNode::setNominalIndividualTriplesAssertionsLoaded(bool loaded) {
802 mLoadedNominalIndiTriplesAssertions = loaded;
803 return this;
804 }
805
806
807 bool CIndividualProcessNode::isNominalIndividualRepresentativeBackendDataLoaded() {
808 return mLoadedNominalIndiRepresentativeBackendData;
809 }
810
811 CIndividualProcessNode* CIndividualProcessNode::setNominalIndividualRepresentativeBackendDataLoaded(bool loaded) {
812 mLoadedNominalIndiRepresentativeBackendData = loaded;
813 return this;
814 }
815
816 cint64 CIndividualProcessNode::getIndividualNodeID() {
817 return mIndiID;
818 }
819
820 CIndividualProcessNode* CIndividualProcessNode::setIndividualNodeID(cint64 indiID) {
821 if (mMergeIntoID == mIndiID) {
822 mMergeIntoID = indiID;
823 }
824 mIndiID = indiID;
825 return this;
826 }
827
828 CIndividualProcessNode::CIndividualType CIndividualProcessNode::getIndividualType() {
829 return mIndiType;
830 }
831
832
833 CIndividualProcessNode* CIndividualProcessNode::setIndividualType(CIndividualProcessNode::CIndividualType indiType) {
834 mIndiType = indiType;
835 return this;
836 }
837
838 CIndividualProcessNode* CIndividualProcessNode::setReapplyConceptLabelSet(CReapplyConceptLabelSet* reapplyConSet) {
839 mUseReapplyConLabelSet = reapplyConSet;
840 mReapplyConLabelSet = reapplyConSet;
841 mPrevReapplyConLabelSet = reapplyConSet;
842 return this;
843 }
844
845 CReapplyConceptLabelSet* CIndividualProcessNode::getReapplyConceptLabelSet(bool create) {
846 if (create && !mReapplyConLabelSet) {
847 mReapplyConLabelSet = CObjectParameterizingAllocator< CReapplyConceptLabelSet,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
848 mReapplyConLabelSet->initConceptLabelSet(mPrevReapplyConLabelSet);
849 mUseReapplyConLabelSet = mReapplyConLabelSet;
850 }
851 return mUseReapplyConLabelSet;
852 }
853
854
855
856 CConnectionSuccessorSet* CIndividualProcessNode::getConnectionSuccessorSet(bool create) {
857 if (create && !mConnSuccSet) {
858 mConnSuccSet = CObjectParameterizingAllocator< CConnectionSuccessorSet,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
859 mConnSuccSet->initConnectionSuccessorSet(mPrevConnSuccSet);
860 mUseConnSuccSet = mConnSuccSet;
861 }
862 return mUseConnSuccSet;
863 }
864
865 CReapplyRoleSuccessorHash* CIndividualProcessNode::getReapplyRoleSuccessorHash(bool create) {
866 if (create && !mReapplyRoleSuccHash) {
867 mReapplyRoleSuccHash = CObjectParameterizingAllocator< CReapplyRoleSuccessorHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
868 mReapplyRoleSuccHash->initRoleSuccessorHash(mPrevReapplyRoleSuccHash);
869 mUseReapplyRoleSuccHash = mReapplyRoleSuccHash;
870 }
871 return mUseReapplyRoleSuccHash;
872 }
873
874
875 CConceptPropagationBindingSetHash* CIndividualProcessNode::getConceptPropagationBindingSetHash(bool create) {
876 if (create && !mConceptPropBindingSetHash) {
877 mConceptPropBindingSetHash = CObjectParameterizingAllocator< CConceptPropagationBindingSetHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
878 mConceptPropBindingSetHash->initConceptPropagationBindingSetHash(mPrevConceptPropBindingSetHash);
879 mUseConceptPropBindingSetHash = mConceptPropBindingSetHash;
880 }
881 return mUseConceptPropBindingSetHash;
882 }
883
884 CConceptVariableBindingPathSetHash* CIndividualProcessNode::getConceptVariableBindingPathSetHash(bool create) {
885 if (create && !mConceptVarBindPathSetHash) {
886 mConceptVarBindPathSetHash = CObjectParameterizingAllocator< CConceptVariableBindingPathSetHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
887 mConceptVarBindPathSetHash->initConceptVariableBindingPathSetHash(mPrevConceptVarBindPathSetHash);
888 mUseConceptVarBindPathSetHash = mConceptVarBindPathSetHash;
889 }
890 return mUseConceptVarBindPathSetHash;
891 }
892
893 CConceptRepresentativePropagationSetHash* CIndividualProcessNode::getConceptRepresentativePropagationSetHash(bool create) {
894 if (create && !mConceptRepPropSetHash) {
895 mConceptRepPropSetHash = CObjectParameterizingAllocator< CConceptRepresentativePropagationSetHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
896 mConceptRepPropSetHash->initConceptRepresentativePropagationSetHash(mPrevConceptRepPropSetHash);
897 mUseConceptRepPropSetHash = mConceptRepPropSetHash;
898 }
899 return mUseConceptRepPropSetHash;
900 }
901
902
903 CRoleSuccessorLinkIterator CIndividualProcessNode::getRoleSuccessorLinkIterator(CRole* role) {
904 if (mUseReapplyRoleSuccHash) {
905 return mUseReapplyRoleSuccHash->getRoleSuccessorLinkIterator(role);
906 } else {
907 return CRoleSuccessorLinkIterator();
908 }
909 }
910
911 cint64 CIndividualProcessNode::getRoleSuccessorCount(CRole* role) {
912 if (mUseReapplyRoleSuccHash) {
913 return mUseReapplyRoleSuccHash->getRoleSuccessorCount(role);
914 } else {
915 return 0;
916 }
917 }
918
919
920 CRoleSuccessorLinkIterator CIndividualProcessNode::getRoleSuccessorHistoryLinkIterator(CRole* role, CIndividualLinkEdge* lastLink) {
921 if (mUseReapplyRoleSuccHash) {
922 return mUseReapplyRoleSuccHash->getRoleSuccessorHistoryLinkIterator(role,lastLink);
923 } else {
924 return CRoleSuccessorLinkIterator();
925 }
926 }
927
928
929 bool CIndividualProcessNode::hasRoleSuccessorToIndividual(CRole* role, cint64 destinationIndiID, bool locateable) {
930 if (mUseReapplyRoleSuccHash) {
931 return mUseReapplyRoleSuccHash->hasRoleSuccessorToIndividual(role,getIndividualNodeID(),destinationIndiID,locateable && mReapplyRoleSuccHash);
932 }
933 return false;
934 }
935
936
937 bool CIndividualProcessNode::hasRoleSuccessorToIndividual(CRole* role, CIndividualProcessNode* desIndi, bool locateable) {
938 return hasRoleSuccessorToIndividual(role,desIndi->getIndividualNodeID(),locateable);
939 }
940
941 CIndividualLinkEdge* CIndividualProcessNode::getRoleSuccessorToIndividualLink(CRole* role, cint64 destinationIndiID, bool locateable) {
942 if (mUseReapplyRoleSuccHash) {
943 return mUseReapplyRoleSuccHash->getRoleSuccessorToIndividualLink(role,getIndividualNodeID(),destinationIndiID,locateable && mReapplyRoleSuccHash);
944 }
945 return nullptr;
946 }
947
948 CIndividualLinkEdge* CIndividualProcessNode::getRoleSuccessorToIndividualLink(CRole* role, CIndividualProcessNode* desIndi, bool locateable) {
949 return getRoleSuccessorToIndividualLink(role,desIndi->getIndividualNodeID(),locateable);
950 }
951
952
953
954 bool CIndividualProcessNode::hasNegationDisjointToIndividual(CRole* role, cint64 destinationIndiID) {
955 if (mUseDisjointSuccRoleHash) {
956 return mUseDisjointSuccRoleHash->hasDisjointSuccessorRoleLink(destinationIndiID,role);
957 }
958 return false;
959 }
960
961
962 bool CIndividualProcessNode::hasNegationDisjointToIndividual(CRole* role, CIndividualProcessNode* desIndi) {
963 return hasNegationDisjointToIndividual(role,desIndi->getIndividualNodeID());
964 }
965
966
967
968 bool CIndividualProcessNode::hasDisjointRoleConnections() {
969 return mDisjointRoleConnections;
970 }
971
972 CIndividualProcessNode* CIndividualProcessNode::setDisjointRoleConnections(bool disjointRoleConnections) {
973 mDisjointRoleConnections = disjointRoleConnections;
974 return this;
975 }
976
977
978
979 CDisjointSuccessorRoleHash* CIndividualProcessNode::getDisjointSuccessorRoleHash(bool create) {
980 if (create && !mDisjointSuccRoleHash) {
981 mDisjointSuccRoleHash = CObjectParameterizingAllocator< CDisjointSuccessorRoleHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
982 mDisjointSuccRoleHash->initDisjointSuccessorRoleHash(mPrevDisjointSuccRoleHash);
983 mUseDisjointSuccRoleHash = mDisjointSuccRoleHash;
984 }
985 return mUseDisjointSuccRoleHash;
986 }
987
988
989 CIndividualProcessNode* CIndividualProcessNode::installDisjointLink(CNegationDisjointEdge* link) {
990 if (!mDisjointSuccRoleHash) {
991 getDisjointSuccessorRoleHash(true);
992 }
993 mUseDisjointSuccRoleHash->insertDisjointSuccessorRoleLink(link->getOppositeIndividualID(mIndiID),link);
994 return this;
995 }
996
997
998 CIndividualProcessNode* CIndividualProcessNode::removeDisjointLinks(cint64 succIndiID) {
999 if (mUseDisjointSuccRoleHash) {
1000 if (!mDisjointSuccRoleHash) {
1001 getDisjointSuccessorRoleHash(true);
1002 }
1003 mUseDisjointSuccRoleHash->removeDisjointSuccessorRoleLinks(succIndiID);
1004 }
1005 return this;
1006 }
1007
1008
1009
1010 CDisjointSuccessorRoleIterator CIndividualProcessNode::getDisjointSuccessorRoleIterator(cint64 succIndiId) {
1011 if (mUseDisjointSuccRoleHash) {
1012 return mUseDisjointSuccRoleHash->getDisjointRoleIterator(succIndiId);
1013 } else {
1014 return CDisjointSuccessorRoleIterator();
1015 }
1016 }
1017
1018 CDisjointSuccessorRoleIterator CIndividualProcessNode::getDisjointSuccessorRoleIterator(CIndividualProcessNode* indiNode) {
1019 return getDisjointSuccessorRoleIterator(indiNode->getIndividualNodeID());
1020 }
1021
1022
1023 CRoleSuccessorIterator CIndividualProcessNode::getRoleIterator() {
1024 if (!mUseReapplyRoleSuccHash) {
1025 return CRoleSuccessorIterator();
1026 } else {
1027 return mUseReapplyRoleSuccHash->getRoleIterator();
1028 }
1029 }
1030
1031
1032 CSuccessorRoleHash* CIndividualProcessNode::getSuccessorRoleHash(bool create) {
1033 if (create && !mSuccRoleHash) {
1034 mSuccRoleHash = CObjectParameterizingAllocator< CSuccessorRoleHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
1035 mSuccRoleHash->initSuccessorRoleHash(mPrevSuccRoleHash);
1036 mUseSuccRoleHash = mSuccRoleHash;
1037 }
1038 return mUseSuccRoleHash;
1039 }
1040
1041 CSuccessorRoleIterator CIndividualProcessNode::getSuccessorRoleIterator(CIndividualProcessNode* indiNode) {
1042 return getSuccessorRoleIterator(indiNode->getIndividualNodeID());
1043 }
1044
1045 CSuccessorRoleIterator CIndividualProcessNode::getSuccessorRoleIterator(cint64 indiID) {
1046 if (!mUseSuccRoleHash) {
1047 return CSuccessorRoleIterator();
1048 } else {
1049 return mUseSuccRoleHash->getSuccessorRoleIterator(indiID);
1050 }
1051 }
1052
1053
1054
1055 bool CIndividualProcessNode::hasSuccessorIndividualNode(CIndividualProcessNode* indiNode) {
1056 return hasSuccessorIndividualNode(indiNode->getIndividualNodeID());
1057 }
1058
1059 bool CIndividualProcessNode::hasSuccessorIndividualNode(cint64 indiID) {
1060 if (!mUseSuccRoleHash) {
1061 return false;
1062 } else {
1063 return mUseSuccRoleHash->hasSuccessorIndividualNode(indiID);
1064 }
1065 }
1066
1067
1068
1069
1070 CConceptProcessingQueue* CIndividualProcessNode::getConceptProcessingQueue(bool create) {
1071 if (create && !mConceptProcessingQueue) {
1072 mConceptProcessingQueue = CObjectParameterizingAllocator< CConceptProcessingQueue,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
1073 mConceptProcessingQueue->initProcessingQueue(mPrevConceptProcessingQueue);
1074 mUseConceptProcessingQueue = mConceptProcessingQueue;
1075 }
1076 return mUseConceptProcessingQueue;
1077 }
1078
1079
1080
1081
1082 CReapplyQueue* CIndividualProcessNode::getRoleReapplyQueue(CRole* role, bool create) {
1083 CReapplyQueue* reapplyQueue = nullptr;
1084 if (create && !mReapplyRoleSuccHash) {
1085 getReapplyRoleSuccessorHash(true);
1086 }
1087 if (mUseReapplyRoleSuccHash) {
1088 reapplyQueue = mUseReapplyRoleSuccHash->getRoleReapplyQueue(role,create);
1089 }
1090 return reapplyQueue;
1091 }
1092
1093
1094 CReapplyQueueIterator CIndividualProcessNode::getRoleReapplyIterator(CRole* role, bool clearDynamicReapllyQueue) {
1095 if (clearDynamicReapllyQueue && !mReapplyRoleSuccHash) {
1096 getReapplyRoleSuccessorHash(true);
1097 }
1098 if (mUseReapplyRoleSuccHash) {
1099 return mUseReapplyRoleSuccHash->getRoleReapplyIterator(role,clearDynamicReapllyQueue);
1100 } else {
1101 return CReapplyQueueIterator(nullptr,nullptr);
1102 }
1103 }
1104
1105 CCondensedReapplyQueue* CIndividualProcessNode::getConceptReapplyQueue(CConcept* concept, bool conceptNegation, bool create) {
1106 CCondensedReapplyQueue* reapplyQueue = 0;
1107 if (create && !mReapplyConLabelSet) {
1108 getReapplyConceptLabelSet(true);
1109 }
1110 if (mUseReapplyConLabelSet) {
1111 reapplyQueue = mUseReapplyConLabelSet->getConceptReapplyQueue(concept,conceptNegation,create);
1112 }
1113 return reapplyQueue;
1114 }
1115
1116
1117 CCondensedReapplyQueueIterator CIndividualProcessNode::getConceptReapplyIterator(CConcept* concept, bool conceptNegation, bool clearDynamicReapllyQueue) {
1118 if (clearDynamicReapllyQueue && !mReapplyConLabelSet) {
1119 getReapplyConceptLabelSet(true);
1120 }
1121 if (mUseReapplyConLabelSet) {
1122 return mUseReapplyConLabelSet->getConceptReapplyIterator(concept,conceptNegation,clearDynamicReapllyQueue);
1123 } else {
1124 return CCondensedReapplyQueueIterator(nullptr,conceptNegation);
1125 }
1126 }
1127
1128
1129
1130
1131 CDistinctHash* CIndividualProcessNode::getDistinctHash(bool create) {
1132 if (create && !mDistinctHash) {
1133 mDistinctHash = CObjectParameterizingAllocator< CDistinctHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
1134 mDistinctHash->initDistinctHash(mPrevDistinctHash);
1135 mUseDistinctHash = mDistinctHash;
1136 }
1137 return mUseDistinctHash;
1138 }
1139
1140
1141
1142
1143 CIndividualProcessNode* CIndividualProcessNode::addBlockedIndividualsLinker(CXLinker<CIndividualProcessNode* >* linker) {
1144 if (linker) {
1145 mBlockedIndividualsLinker = linker->append(mBlockedIndividualsLinker);
1146 }
1147 return this;
1148 }
1149
1150 CIndividualProcessNode* CIndividualProcessNode::setBlockedIndividualsLinker(CXLinker<CIndividualProcessNode* >* linker) {
1151 mBlockedIndividualsLinker = linker;
1152 return this;
1153 }
1154
1155 CXLinker<CIndividualProcessNode* >* CIndividualProcessNode::getBlockedIndividualsLinker() {
1156 return mBlockedIndividualsLinker;
1157 }
1158
1159
1160 bool CIndividualProcessNode::hasBlockedIndividualsLinker() {
1161 return mBlockedIndividualsLinker;
1162 }
1163
1164
1165 CIndividualProcessNode* CIndividualProcessNode::clearBlockedIndividualsLinker() {
1166 mBlockedIndividualsLinker = nullptr;
1167 return this;
1168 }
1169
1170 CIndividualLinkEdge* CIndividualProcessNode::getAncestorLink() {
1171 return mAncestorLink;
1172 }
1173
1174 CIndividualProcessNode* CIndividualProcessNode::setAncestorLink(CIndividualLinkEdge* link) {
1175 mAncestorLink = link;
1176 return this;
1177 }
1178
1179 bool CIndividualProcessNode::isIndividualAncestor(CIndividualProcessNode* individual) {
1180 if (mAncestorLink) {
1181 return mAncestorLink->isSourceIndividualID(individual);
1182 }
1183 return false;
1184 }
1185
1186
1187
1188 bool CIndividualProcessNode::hasIndividualAncestor() {
1189 return mAncestorLink != nullptr;
1190 }
1191
1192
1193 bool CIndividualProcessNode::isBlockableIndividual() {
1194 return mIndiType == BLOCKABLEINDIVIDUALTYPE;
1195 }
1196
1197 bool CIndividualProcessNode::isNominalIndividualNode() {
1198 return mIndiType == NOMINALINDIVIDUALTYPE;
1199 }
1200
1201
1202 CIndividual* CIndividualProcessNode::getNominalIndividual() {
1203 return mNomIndi;
1204 }
1205
1206 CIndividualProcessNode* CIndividualProcessNode::setNominalIndividual(CIndividual* indi) {
1207 mNomIndi = indi;
1208 return this;
1209 }
1210
1211
1212 CIndividualLinkEdge* CIndividualProcessNode::getLastAddedRoleLink() {
1213 return mLastAddedLink;
1214 }
1215
1216
1217 cint64 CIndividualProcessNode::installIndividualLink(CIndividualLinkEdge* link, CReapplyQueueIterator* reapplyQueueIt) {
1218 if (!mReapplyRoleSuccHash) {
1219 getReapplyRoleSuccessorHash(true);
1220 }
1221 if (!mSuccRoleHash) {
1222 getSuccessorRoleHash(true);
1223 }
1224 cint64 linkCount = mUseReapplyRoleSuccHash->insertRoleSuccessorLink(link->getLinkRole(),link,reapplyQueueIt);
1225 cint64 oppIndiID = link->getOppositeIndividualID(mIndiID);
1226 mUseSuccRoleHash->insertSuccessorRoleLink(oppIndiID,link);
1227 mLastAddedLink = link;
1228 return linkCount;
1229 }
1230
1231 CIndividualProcessNode* CIndividualProcessNode::removeIndividualLink(CIndividualLinkEdge* link) {
1232 if (!mReapplyRoleSuccHash) {
1233 getReapplyRoleSuccessorHash(true);
1234 }
1235 mUseReapplyRoleSuccHash->removeRoleSuccessorLink(link->getLinkRole(),link);
1236 return this;
1237 }
1238
1239
1240 CIndividualProcessNode* CIndividualProcessNode::removeIndividualConnection(CIndividualProcessNode* indi) {
1241 if (!mSuccRoleHash) {
1242 getSuccessorRoleHash(true);
1243 }
1244 mSuccRoleHash->removeSuccessor(indi->getIndividualNodeID());
1245 if (mUseConnSuccSet) {
1246 if (!mConnSuccSet) {
1247 getConnectionSuccessorSet(true);
1248 }
1249 mConnSuccSet->removeConnection(indi->getIndividualNodeID());
1250 }
1251 return this;
1252 }
1253
1254
1255
1256 CSuccessorIterator CIndividualProcessNode::getSuccessorIterator() {
1257 if (!mUseSuccRoleHash) {
1258 return CSuccessorIterator();
1259 }
1260 return mUseSuccRoleHash->getSuccessorIterator();
1261 }
1262
1263
1264
1265 CConnectionSuccessorSetIterator CIndividualProcessNode::getConnectionSuccessorIterator() {
1266 if (mUseConnSuccSet) {
1267 return mUseConnSuccSet->getConnectionSuccessorIterator();
1268 } else {
1269 return CConnectionSuccessorSetIterator();
1270 }
1271 }
1272
1273
1274
1275 CIndividualNodeModelData* CIndividualProcessNode::getIndividualModelData() {
1276 return indiModel;
1277 }
1278
1279 CIndividualProcessNode* CIndividualProcessNode::setIndividualModelData(CIndividualNodeModelData* individualModel) {
1280 indiModel = individualModel;
1281 return this;
1282 }
1283
1284
1285 CIndividualNodeSatisfiableCacheRetrievalData* CIndividualProcessNode::getIndividualSatisfiableCacheRetrievalData(bool localCacheData) {
1286 if (localCacheData) {
1287 return mSatCacheRetData;
1288 } else {
1289 return mPrevSatCacheRetData;
1290 }
1291 }
1292
1293 CIndividualProcessNode* CIndividualProcessNode::setIndividualSatisfiableCacheRetrievalData(CIndividualNodeSatisfiableCacheRetrievalData* satCacheRetrievalData) {
1294 mSatCacheRetData = satCacheRetrievalData;
1295 mPrevSatCacheRetData = mSatCacheRetData;
1296 return this;
1297 }
1298
1299
1300
1301
1302 CIndividualNodeBackendCacheSynchronisationData* CIndividualProcessNode::getIndividualBackendCacheSynchronisationData(bool localCacheData) {
1303 if (localCacheData) {
1304 return mBackendSyncData;
1305 } else {
1306 return mPrevBackendSyncData;
1307 }
1308 }
1309
1310 CIndividualProcessNode* CIndividualProcessNode::setIndividualBackendCacheSynchronisationData(CIndividualNodeBackendCacheSynchronisationData* backendSyncData) {
1311 mBackendSyncData = backendSyncData;
1312 mPrevBackendSyncData = backendSyncData;
1313 return this;
1314 }
1315
1316
1317
1318
1319 CIndividualNodeSatisfiableCacheStoringData* CIndividualProcessNode::getIndividualSatisfiableCacheStoringData(bool localCacheData) {
1320 if (localCacheData) {
1321 return mSatCacheStoringData;
1322 } else {
1323 return mPrevSatCacheStoringData;
1324 }
1325 }
1326
1327 CIndividualProcessNode* CIndividualProcessNode::setIndividualSatisfiableCacheStoringData(CIndividualNodeSatisfiableCacheStoringData* satCacheStoringData) {
1328 mSatCacheStoringData = satCacheStoringData;
1329 mPrevSatCacheStoringData = mSatCacheStoringData;
1330 return this;
1331 }
1332
1333 CIndividualNodeUnsatisfiableCacheRetrievalData* CIndividualProcessNode::getIndividualUnsatisfiableCacheRetrievalData(bool localUnsatCacheRetData) {
1334 if (localUnsatCacheRetData) {
1335 return mIndiUnsatCacheRet;
1336 } else {
1337 return mPrevIndiUnsatCacheRet;
1338 }
1339 }
1340
1341 CIndividualProcessNode* CIndividualProcessNode::setIndividualUnsatisfiableCacheRetrievalData(CIndividualNodeUnsatisfiableCacheRetrievalData* individualUnsatCacheRetData) {
1342 mIndiUnsatCacheRet = individualUnsatCacheRetData;
1343 mPrevIndiUnsatCacheRet = mIndiUnsatCacheRet;
1344 return this;
1345 }
1346
1347
1348 CSignatureBlockingIndividualNodeConceptExpansionData* CIndividualProcessNode::getSignatureBlockingIndividualNodeConceptExpansionData(bool localBlockingData) {
1349 if (localBlockingData) {
1350 return mSigBlockConExpData;
1351 } else {
1352 return mPrevSigBlockConExpData;
1353 }
1354 }
1355
1356 CIndividualProcessNode* CIndividualProcessNode::setSignatureBlockingIndividualNodeConceptExpansionData(CSignatureBlockingIndividualNodeConceptExpansionData* individualBlockingData) {
1357 mSigBlockConExpData = individualBlockingData;
1358 mPrevSigBlockConExpData = mSigBlockConExpData;
1359 return this;
1360 }
1361
1362
1363 CReusingIndividualNodeConceptExpansionData* CIndividualProcessNode::getReusingIndividualNodeConceptExpansionData(bool localBlockingData) {
1364 if (localBlockingData) {
1365 return mReusingConExpData;
1366 } else {
1367 return mPrevReusingConExpData;
1368 }
1369 }
1370
1371 CIndividualProcessNode* CIndividualProcessNode::setReusingIndividualNodeConceptExpansionData(CReusingIndividualNodeConceptExpansionData* individualBlockingData) {
1372 mReusingConExpData = individualBlockingData;
1373 mPrevReusingConExpData = mReusingConExpData;
1374 return this;
1375 }
1376
1377
1378 CIndividualNodeAnalizedConceptExpansionData* CIndividualProcessNode::getAnalizedConceptExpansionData(bool createOrLocalize) {
1379 if (!mSigBlockIndExplData && createOrLocalize) {
1380 mSigBlockIndExplData = CObjectAllocator<CIndividualNodeAnalizedConceptExpansionData>::allocateAndConstruct(mMemAllocMan);
1381 mSigBlockIndExplData->initBlockingExplorationData(mPrevSigBlockIndExplData);
1382 mUseSigBlockIndExplData = mSigBlockIndExplData;
1383 }
1384 return mUseSigBlockIndExplData;
1385 }
1386
1387
1388 CBlockingFollowSet* CIndividualProcessNode::getBlockingFollowSet(bool createOrLocalize) {
1389 if (!mSigBlockFollowSet && createOrLocalize) {
1390 mSigBlockFollowSet = CObjectParameterizingAllocator< CBlockingFollowSet,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
1391 mSigBlockFollowSet->initBlockingFollowSet(mPrevSigBlockFollowSet);
1392 mUseSigBlockFollowSet = mSigBlockFollowSet;
1393 }
1394 return mUseSigBlockFollowSet;
1395 }
1396
1397
1398 bool CIndividualProcessNode::hasBlockingFollower() {
1399 if (!mUseSigBlockFollowSet) {
1400 return false;
1401 } else {
1402 return !mUseSigBlockFollowSet->empty();
1403 }
1404 }
1405
1406
1407 CIndividualNodeSaturationBlockingData* CIndividualProcessNode::getIndividualSaturationBlockingData(bool localBlockData) {
1408 if (localBlockData) {
1409 return mIndiSatBlockData;
1410 } else {
1411 return mPrevIndiSatBlockData;
1412 }
1413 }
1414
1415 CIndividualProcessNode* CIndividualProcessNode::setIndividualSaturationBlockingData(CIndividualNodeSaturationBlockingData* individualBlock) {
1416 mIndiSatBlockData = individualBlock;
1417 mPrevIndiSatBlockData = individualBlock;
1418 return this;
1419 }
1420
1421
1422 CIndividualNodeBlockData* CIndividualProcessNode::getIndividualBlockData(bool localBlockData) {
1423 if (localBlockData) {
1424 return mIndiBlock;
1425 } else {
1426 return mPrevIndiBlock;
1427 }
1428 }
1429
1430 CIndividualProcessNode* CIndividualProcessNode::setIndividualBlockData(CIndividualNodeBlockData* individualBlock) {
1431 mIndiBlock = individualBlock;
1432 mPrevIndiBlock = mIndiBlock;
1433 return this;
1434 }
1435
1436
1437 CBlockingVariableBindingsAnalogousPropagationData* CIndividualProcessNode::getVariableBindingsPropagationBlockingData(bool localBlockData) {
1438 if (localBlockData) {
1439 return mIndiVarPropBlockData;
1440 } else {
1441 return mPrevIndiVarPropBlockData;
1442 }
1443 }
1444
1445 CIndividualProcessNode* CIndividualProcessNode::setVariableBindingsPropagationBlockingData(CBlockingVariableBindingsAnalogousPropagationData* blockData) {
1446 mIndiVarPropBlockData = blockData;
1447 mPrevIndiVarPropBlockData = blockData;
1448 return this;
1449 }
1450
1451
1452 cint64 CIndividualProcessNode::getIndividualAncestorDepth() {
1453 return indiAncDepth;
1454 }
1455
1456 CIndividualProcessNode* CIndividualProcessNode::setIndividualAncestorDepth(cint64 depth) {
1457 indiAncDepth = depth;
1458 return this;
1459 }
1460
1461 cint64 CIndividualProcessNode::getIndividualNominalLevel() {
1462 return mNominalLevel;
1463 }
1464
1465 CIndividualProcessNode* CIndividualProcessNode::setIndividualNominalLevel(cint64 level) {
1466 mNominalLevel = level;
1467 return this;
1468 }
1469
1470 cint64 CIndividualProcessNode::getIndividualNominalLevelOrAncestorDepth() {
1471 if (isNominalIndividualNode()) {
1472 return getIndividualNominalLevel();
1473 }
1474 return getIndividualAncestorDepth();
1475 }
1476
1477
1478 cint64 CIndividualProcessNode::getMergedIntoIndividualNodeID() {
1479 return mMergeIntoID;
1480 }
1481
1482 bool CIndividualProcessNode::hasMergedIntoIndividualNodeID() {
1483 return mMergeIntoID != mIndiID;
1484 }
1485
1486 CIndividualProcessNode* CIndividualProcessNode::setMergedIntoIndividualNodeID(cint64 indiNodeID) {
1487 mMergeIntoID = indiNodeID;
1488 return this;
1489 }
1490
1491
1492 CIndividualProcessNode* CIndividualProcessNode::addProcessingBlockedIndividualsLinker(CXLinker<CIndividualProcessNode*>* linker) {
1493 if (linker) {
1494 mProcessingBlockedIndividualsLinker = linker->append(mProcessingBlockedIndividualsLinker);
1495 }
1496 return this;
1497 }
1498
1499 CIndividualProcessNode* CIndividualProcessNode::setIndirectBlockedIndividualsLinker(CXLinker<CIndividualProcessNode*>* linker) {
1500 mProcessingBlockedIndividualsLinker = linker;
1501 return this;
1502 }
1503
1504 CXLinker<CIndividualProcessNode*>* CIndividualProcessNode::getProcessingBlockedIndividualsLinker() {
1505 return mProcessingBlockedIndividualsLinker;
1506 }
1507
1508
1509 CReapplyConceptDescriptor* CIndividualProcessNode::getSatisfiableCachedAbsorbedDisjunctionsLinker() {
1510 return mSatCachedAbsorbedDisjunctionsReapplyConDes;
1511 }
1512
1513 CIndividualProcessNode* CIndividualProcessNode::clearSatisfiableCachedAbsorbedDisjunctionsLinker() {
1514 mSatCachedAbsorbedDisjunctionsReapplyConDes = nullptr;
1515 return this;
1516 }
1517
1518 CIndividualProcessNode* CIndividualProcessNode::addSatisfiableCachedAbsorbedDisjunctionsLinker(CReapplyConceptDescriptor* disjunctionReapplyConDes) {
1519 if (!mSatCachedAbsorbedDisjunctionsReapplyConDes) {
1520 mSatCachedAbsorbedDisjunctionsReapplyConDes = disjunctionReapplyConDes;
1521 } else {
1522 disjunctionReapplyConDes->setNext(mSatCachedAbsorbedDisjunctionsReapplyConDes);
1523 mSatCachedAbsorbedDisjunctionsReapplyConDes = disjunctionReapplyConDes;
1524 }
1525 return this;
1526 }
1527
1528
1529
1530 CIndividualProcessNode* CIndividualProcessNode::clearSatisfiableCachedAbsorbedGeneratingLinker() {
1531 mSatCachedAbsorbedSuccessorReapplyConDes = nullptr;
1532 return this;
1533 }
1534
1535 CReapplyConceptDescriptor* CIndividualProcessNode::getSatisfiableCachedAbsorbedGeneratingLinker() {
1536 return mSatCachedAbsorbedSuccessorReapplyConDes;
1537 }
1538
1539 CIndividualProcessNode* CIndividualProcessNode::addSatisfiableCachedAbsorbedGeneratingLinker(CReapplyConceptDescriptor* successorGeneratingReapplyConDes) {
1540 if (!mSatCachedAbsorbedSuccessorReapplyConDes) {
1541 mSatCachedAbsorbedSuccessorReapplyConDes = successorGeneratingReapplyConDes;
1542 } else {
1543 successorGeneratingReapplyConDes->setNext(mSatCachedAbsorbedSuccessorReapplyConDes);
1544 mSatCachedAbsorbedSuccessorReapplyConDes = successorGeneratingReapplyConDes;
1545 }
1546 return this;
1547 }
1548
1549
1550
1551 cint64 CIndividualProcessNode::getProcessingRestrictionFlags() {
1552 return mProcessingRestrictionFlags;
1553 }
1554
1555 bool CIndividualProcessNode::addProcessingRestrictionFlags(cint64 flags) {
1556 cint64 flagsBackup = mProcessingRestrictionFlags;
1557 mProcessingRestrictionFlags |= flags;
1558 return mProcessingRestrictionFlags != flagsBackup;
1559 }
1560
1561 bool CIndividualProcessNode::clearProcessingRestrictionFlags(cint64 flags) {
1562 cint64 flagsBackup = mProcessingRestrictionFlags;
1563 mProcessingRestrictionFlags &= ~flags;
1564 return mProcessingRestrictionFlags != flagsBackup;
1565 }
1566
1567 bool CIndividualProcessNode::hasProcessingRestrictionFlags(cint64 testFlags) {
1568 return (mProcessingRestrictionFlags & testFlags) == testFlags;
1569 }
1570
1571 bool CIndividualProcessNode::hasPartialProcessingRestrictionFlags(cint64 testFlags) {
1572 return (mProcessingRestrictionFlags & testFlags) != 0;
1573 }
1574
1575
1576 CConceptDescriptor* CIndividualProcessNode::getIndividualInitializationConcept() {
1577 return mInitConceptDescriptor;
1578 }
1579
1580 CIndividualProcessNode* CIndividualProcessNode::setIndividualInitializationConcept(CConceptDescriptor* initConDes) {
1581 mInitConceptDescriptor = initConDes;
1582 return this;
1583 }
1584
1585 bool CIndividualProcessNode::hasBlockingRetestProcessingRestrictionFlags() {
1586 return hasPartialProcessingRestrictionFlags(PRFBLOCKINGRETESTDUEANCESTORMODIFIED | PRFBLOCKINGRETESTDUEDIRECTMODIFIED | PRFBLOCKINGRETESTDUEBLOCKERMODIFIED | PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS | PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED);
1587 }
1588
1589 bool CIndividualProcessNode::clearBlockingRetestProcessingRestrictionFlags() {
1590 return clearProcessingRestrictionFlags(PRFBLOCKINGRETESTDUEANCESTORMODIFIED | PRFBLOCKINGRETESTDUEDIRECTMODIFIED | PRFBLOCKINGRETESTDUEBLOCKERMODIFIED | PRFBLOCKINGRETESTDUEINDIRECTBLOCKERLOSS | PRFBLOCKINGRETESTDUEPROCESSINGCOMPLETED);
1591 }
1592
1593 bool CIndividualProcessNode::hasBlockedProcessingRestrictionFlags() {
1594 return hasPartialProcessingRestrictionFlags(PRFDIRECTBLOCKED | PRFINDIRECTBLOCKED | PRFPROCESSINGBLOCKED);
1595 }
1596
1597 bool CIndividualProcessNode::hasDirectBlockedProcessingRestrictionFlags() {
1598 return hasPartialProcessingRestrictionFlags(PRFDIRECTBLOCKED);
1599 }
1600
1601 bool CIndividualProcessNode::hasProcessingBlockedProcessingRestrictionFlags() {
1602 return hasPartialProcessingRestrictionFlags(PRFPROCESSINGBLOCKED);
1603 }
1604
1605 bool CIndividualProcessNode::hasPurgedBlockedProcessingRestrictionFlags() {
1606 return hasPartialProcessingRestrictionFlags(PRFPURGEDBLOCKED);
1607 }
1608
1609 bool CIndividualProcessNode::hasIndirectBlockedProcessingRestrictionFlags() {
1610 return hasPartialProcessingRestrictionFlags(PRFINDIRECTBLOCKED);
1611 }
1612
1613 bool CIndividualProcessNode::clearBlockedProcessingRestrictionFlags() {
1614 return clearProcessingRestrictionFlags(PRFDIRECTBLOCKED | PRFINDIRECTBLOCKED | PRFPROCESSINGBLOCKED);
1615 }
1616
1617
1618
1619 CIndividualProcessNode* CIndividualProcessNode::setLastConceptCountCachedBlockingCandidate(cint64 conCount) {
1620 mLastConceptCountCachedBlockerCandidate = conCount;
1621 return this;
1622 }
1623
1624 cint64 CIndividualProcessNode::getLastConceptCountCachedBlockingCandidate() {
1625 return mLastConceptCountCachedBlockerCandidate;
1626 }
1627
1628 cint64 CIndividualProcessNode::getLastConceptCountSearchBlockingCandidate() {
1629 return mLastConceptCountSearchBlockerCandidate;
1630 }
1631
1632 CIndividualProcessNode* CIndividualProcessNode::setLastConceptCountSearchBlockingCandidate(cint64 conCount) {
1633 mLastConceptCountSearchBlockerCandidate = conCount;
1634 return this;
1635 }
1636
1637
1638
1639 cint64 CIndividualProcessNode::getBlockingCachingSavedCandidateCount() {
1640 return mBlockingCachingSavedCandidateCount;
1641 }
1642
1643 CIndividualProcessNode* CIndividualProcessNode::setBlockingCachingSavedCandidateCount(cint64 conCount) {
1644 mBlockingCachingSavedCandidateCount = conCount;
1645 return this;
1646 }
1647
1648 CIndividualProcessNode* CIndividualProcessNode::incBlockingCachingSavedCandidateCount(cint64 incCount) {
1649 mBlockingCachingSavedCandidateCount += incCount;
1650 return this;
1651 }
1652
1653
1654 cint64 CIndividualProcessNode::getLastSearchBlockerCandidateCount() {
1655 return mLastSearchBlockerCandidateCount;
1656 }
1657
1658 CIndividualProcessNode* CIndividualProcessNode::setLastSearchBlockerCandidateCount(cint64 canCount) {
1659 mLastSearchBlockerCandidateCount = canCount;
1660 return this;
1661 }
1662
1663 cint64 CIndividualProcessNode::getLastSearchBlockerCandidateSignature() {
1664 return mLastSearchBlockerCandidateSignature;
1665 }
1666
1667 CIndividualProcessNode* CIndividualProcessNode::setLastSearchBlockerCandidateSignature(cint64 canCount) {
1668 mLastSearchBlockerCandidateSignature = canCount;
1669 return this;
1670 }
1671
1672
1673 bool CIndividualProcessNode::isInvalidSignatureBlocking() {
1674 return mInvalidSignatureBlocking;
1675 }
1676
1677 CIndividualProcessNode* CIndividualProcessNode::setInvalidSignatureBlocking(bool invalid) {
1678 mInvalidSignatureBlocking = invalid;
1679 return this;
1680 }
1681
1682
1683
1684
1685
1686
1687 CIndividualProcessNode* CIndividualProcessNode::addSuccessorIndividualNodeBackwardDependencyLinker(CXLinker<CIndividualProcessNode* >* linker) {
1688 if (linker) {
1689 mSuccessorIndiNodeBackwardDependencyLinker = linker->append(mSuccessorIndiNodeBackwardDependencyLinker);
1690 }
1691 return this;
1692 }
1693
1694 CIndividualProcessNode* CIndividualProcessNode::setSuccessorIndividualNodeBackwardDependencyLinker(CXLinker<CIndividualProcessNode* >* linker) {
1695 mSuccessorIndiNodeBackwardDependencyLinker = linker;
1696 return this;
1697 }
1698
1699 CXLinker<CIndividualProcessNode* >* CIndividualProcessNode::getSuccessorIndividualNodeBackwardDependencyLinker() {
1700 return mSuccessorIndiNodeBackwardDependencyLinker;
1701 }
1702
1703
1704 bool CIndividualProcessNode::hasSuccessorIndividualNodeBackwardDependencyLinker() {
1705 return mSuccessorIndiNodeBackwardDependencyLinker;
1706 }
1707
1708 CIndividualProcessNode* CIndividualProcessNode::clearSuccessorIndividualNodeBackwardDependencyLinker() {
1709 mSuccessorIndiNodeBackwardDependencyLinker = nullptr;
1710 return this;
1711 }
1712
1713
1714 bool CIndividualProcessNode::hasBackwardDependencyToAncestorIndividualNode() {
1715 return mBackwardDependencyToAncestorIndividualNode;
1716 }
1717
1718 CIndividualProcessNode* CIndividualProcessNode::setBackwardDependencyToAncestorIndividualNode(bool backwardDependency) {
1719 mBackwardDependencyToAncestorIndividualNode = backwardDependency;
1720 return this;
1721 }
1722
1723
1724 CRoleBackwardPropagationHash* CIndividualProcessNode::getRoleBackwardPropagationHash(bool create) {
1725 if (create && !mRoleBackPropHash) {
1726 mRoleBackPropHash = CObjectParameterizingAllocator< CRoleBackwardPropagationHash,CProcessContext* >::allocateAndConstructAndParameterize(mMemAllocMan,mProcessContext);
1727 }
1728 return mRoleBackPropHash;
1729 }
1730
1731 CIndividualProcessNodeLinker* CIndividualProcessNode::getIndividualProcessNodeLinker() {
1732 return mIndiProcessLinker;
1733 }
1734
1735 CIndividualProcessNode* CIndividualProcessNode::setIndividualProcessNodeLinker(CIndividualProcessNodeLinker* processNodeLinker) {
1736 mIndiProcessLinker = processNodeLinker;
1737 return this;
1738 }
1739
1740 CConceptProcessLinker* CIndividualProcessNode::getConceptProcessLinker() {
1741 return mConceptProcessLinker;
1742 }
1743
1744 CConceptProcessLinker* CIndividualProcessNode::takeConceptProcessLinker() {
1745 CConceptProcessLinker* conProcLinker = mConceptProcessLinker;
1746 if (mConceptProcessLinker) {
1747 mConceptProcessLinker = mConceptProcessLinker->getNext();
1748 }
1749 return conProcLinker;
1750 }
1751
1752 CIndividualProcessNode* CIndividualProcessNode::setConceptProcessLinker(CConceptProcessLinker* conProcessLinker) {
1753 mConceptProcessLinker = conProcessLinker;
1754 return this;
1755 }
1756
1757 CIndividualProcessNode* CIndividualProcessNode::addConceptProcessLinker(CConceptProcessLinker* conProcessLinker) {
1758 mConceptProcessLinker = conProcessLinker->append(mConceptProcessLinker);
1759 return this;
1760 }
1761
1762 CIndividualProcessNode* CIndividualProcessNode::clearConceptProcessLinker() {
1763 mConceptProcessLinker = nullptr;
1764 return this;
1765 }
1766
1767 bool CIndividualProcessNode::getRequiredBackwardPropagation() {
1768 return mRequiredBackProp;
1769 }
1770
1771 CIndividualProcessNode* CIndividualProcessNode::setRequiredBackwardPropagation(bool requiredBackProp) {
1772 mRequiredBackProp = requiredBackProp;
1773 return this;
1774 }
1775
1776 bool CIndividualProcessNode::hasSubstituteIndividualNode() {
1777 return mSubstituteIndiNode != nullptr;
1778 }
1779
1780 CIndividualProcessNode* CIndividualProcessNode::getSubstituteIndividualNode() {
1781 return mSubstituteIndiNode;
1782 }
1783
1784 CIndividualProcessNode* CIndividualProcessNode::setSubstituteIndividualNode(CIndividualProcessNode* indiNode) {
1785 mSubstituteIndiNode = indiNode;
1786 return this;
1787 }
1788
1789 bool CIndividualProcessNode::isProcessingQueued() {
1790 return mProcessingQueued;
1791 }
1792
1793 bool CIndividualProcessNode::isExtendedQueueProcessing() {
1794 return mExtendedQueueProcessing;
1795 }
1796
1797 bool CIndividualProcessNode::isImmediatelyProcessingQueued() {
1798 return mImmediatelyProcessingQueued;
1799 }
1800
1801 bool CIndividualProcessNode::isDeterministicExpandingProcessingQueued() {
1802 return mDetExpProcessingQueued;
1803 }
1804
1805 bool CIndividualProcessNode::isRegularDepthProcessingQueued() {
1806 return mDepthProcessingQueued;
1807 }
1808
1809 bool CIndividualProcessNode::isBlockedReactivationProcessingQueued() {
1810 return mBlockedReactProcessingQueued;
1811 }
1812
1813 CIndividualProcessNode* CIndividualProcessNode::setProcessingQueued(bool processingQueued) {
1814 mProcessingQueued = processingQueued;
1815 return this;
1816 }
1817
1818 CIndividualProcessNode* CIndividualProcessNode::setExtendedQueueProcessing(bool extendedQueueProcessing) {
1819 mExtendedQueueProcessing = extendedQueueProcessing;
1820 return this;
1821 }
1822
1823 CIndividualProcessNode* CIndividualProcessNode::setImmediatelyProcessingQueued(bool immProQue) {
1824 mImmediatelyProcessingQueued = immProQue;
1825 return this;
1826 }
1827
1828 CIndividualProcessNode* CIndividualProcessNode::setDeterministicExpandingProcessingQueued(bool immProQue) {
1829 mDetExpProcessingQueued = immProQue;
1830 return this;
1831 }
1832
1833 CIndividualProcessNode* CIndividualProcessNode::setRegularDepthProcessingQueued(bool depthPro) {
1834 mDepthProcessingQueued = depthPro;
1835 return this;
1836 }
1837
1838 CIndividualProcessNode* CIndividualProcessNode::setBlockedReactivationProcessingQueued(bool depthPro) {
1839 mBlockedReactProcessingQueued = depthPro;
1840 return this;
1841 }
1842
1843
1844
1845 CIndividualProcessNode* CIndividualProcessNode::setBackendSynchronRetestProcessingQueued(bool backendSyncRetest) {
1846 mBackendSynchronRetestProcessingQueued = backendSyncRetest;
1847 return this;
1848 }
1849
1850
1851 bool CIndividualProcessNode::isBackendSynchronRetestProcessingQueued() {
1852 return mBackendSynchronRetestProcessingQueued;
1853 }
1854
1855
1856
1857
1858
1859 CIndividualProcessNode* CIndividualProcessNode::setBackendIndirectCompatibilityExpansionQueued(bool queued) {
1860 mBackendIndirectCompatibilityExpansionQueued = queued;
1861 return this;
1862 }
1863
1864
1865 bool CIndividualProcessNode::isBackendIndirectCompatibilityExpansionQueued() {
1866 return mBackendIndirectCompatibilityExpansionQueued;
1867 }
1868
1869
1870
1871
1872 CIndividualProcessNode* CIndividualProcessNode::setBackendDirectInfluenceExpansionQueued(bool queued) {
1873 mBackendDirectInfluenceExpansionQueued = queued;
1874 return this;
1875 }
1876
1877
1878 bool CIndividualProcessNode::isBackendDirectInfluenceExpansionQueued() {
1879 return mBackendDirectInfluenceExpansionQueued;
1880 }
1881
1882
1883
1884
1885 CIndividualProcessNode* CIndividualProcessNode::setIncrementalCompatibilityCheckingQueued(bool incCompChecking) {
1886 mIncrementalCompatibilityCheckingQueued = incCompChecking;
1887 return this;
1888 }
1889
1890
1891 bool CIndividualProcessNode::isIncrementalCompatibilityCheckingQueued() {
1892 return mIncrementalCompatibilityCheckingQueued;
1893 }
1894
1895
1896
1897
1898 CIndividualProcessNode* CIndividualProcessNode::setIncrementalExpansionQueued(bool incExpQueued) {
1899 mIncrementalExpansionQueued = incExpQueued;
1900 return this;
1901 }
1902
1903
1904 bool CIndividualProcessNode::isIncrementalExpansionQueued() {
1905 return mIncrementalExpansionQueued;
1906 }
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916 CIndividualProcessNode* CIndividualProcessNode::setBackendReuseExpansionQueued(bool queued) {
1917 mBackendReuseExpansionQueued = queued;
1918 return this;
1919 }
1920
1921
1922 bool CIndividualProcessNode::isBackendReuseExpansionQueued() {
1923 return mBackendReuseExpansionQueued;
1924 }
1925
1926
1927
1928
1929 CIndividualProcessNode* CIndividualProcessNode::setBackendNeighbourExpansionQueued(bool queued) {
1930 mBackendNeighbourExpansionQueued = queued;
1931 return this;
1932 }
1933
1934
1935 bool CIndividualProcessNode::isBackendNeighbourExpansionQueued() {
1936 return mBackendNeighbourExpansionQueued;
1937 }
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952 CIndividualProcessNode* CIndividualProcessNode::clearProcessingQueued() {
1953 mBlockedReactProcessingQueued = false;
1954 mProcessingQueued = false;
1955 mImmediatelyProcessingQueued = false;
1956 mDetExpProcessingQueued = false;
1957 mDepthProcessingQueued = false;
1958 mDelayedNominalProcessingQueued = false;
1959 mBackendSynchronRetestProcessingQueued = false;
1960 mBackendDirectInfluenceExpansionQueued = false;
1961 mBackendIndirectCompatibilityExpansionQueued = false;
1962 mIncrementalCompatibilityCheckingQueued = false;
1963 mIncrementalExpansionQueued = false;
1964 return this;
1965 }
1966
1967
1968 bool CIndividualProcessNode::isDelayedNominalProcessingQueued() {
1969 return mDelayedNominalProcessingQueued;
1970 }
1971
1972 bool CIndividualProcessNode::hasNominalProcessingDelayingChecked() {
1973 return mNominalProcessingDelayingChecked;
1974 }
1975
1976 CIndividualProcessNode* CIndividualProcessNode::setDelayedNominalProcessingQueued(bool delayedProcessingQueued) {
1977 mDelayedNominalProcessingQueued = delayedProcessingQueued;
1978 return this;
1979 }
1980
1981 CIndividualProcessNode* CIndividualProcessNode::setNominalProcessingDelayingChecked(bool nominalProcessingDelayingChecked) {
1982 mNominalProcessingDelayingChecked = nominalProcessingDelayingChecked;
1983 return this;
1984 }
1985
1986
1987 CIndividualProcessNode* CIndividualProcessNode::setAssertionInitialisationSignatureValue(cint64 sigValue) {
1988 mAssertionInitialisationSignatureValue = sigValue;
1989 return this;
1990 }
1991
1992 cint64 CIndividualProcessNode::getAssertionInitialisationSignatureValue() {
1993 return mAssertionInitialisationSignatureValue;
1994 }
1995
1996
1997 CIndividualProcessNode* CIndividualProcessNode::setLastProcessingPriority(const CIndividualProcessNodePriority& priority) {
1998 mLastProcessingPriority = priority;
1999 return this;
2000 }
2001
2002 CIndividualProcessNode* CIndividualProcessNode::resetLastProcessingPriority() {
2003 mLastProcessingPriority.setPriorityToNull();
2004 return this;
2005 }
2006
2007 CIndividualProcessNodePriority CIndividualProcessNode::getLastProcessingPriority() {
2008 return mLastProcessingPriority;
2009 }
2010
2011 bool CIndividualProcessNode::isCachingLossNodeReactivationInstalled() {
2012 return mCachingLossNodeReactivationInstalled;
2013 }
2014
2015 CIndividualProcessNode* CIndividualProcessNode::setCachingLossNodeReactivationInstalled(bool reactivationInstalled) {
2016 mCachingLossNodeReactivationInstalled = reactivationInstalled;
2017 return this;
2018 }
2019
2020
2021
2022 CNominalCachingLossReactivationData* CIndividualProcessNode::getNominalCachingLossReactivationData(bool create) {
2023 CNominalCachingLossReactivationData* nominalNodeReactData = nullptr;
2024 if (!mLocReactivationData && create) {
2025 CNominalCachingLossReactivationData* nominalNodeReactData = CObjectParameterizingAllocator< CNominalCachingLossReactivationData,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
2026 nominalNodeReactData->initNominalCachingLossReactivationData(getIndividualNodeID(),mUseReactivationData);
2027 mLocReactivationData = nominalNodeReactData;
2028 mUseReactivationData = nominalNodeReactData;
2029 }
2030 return mUseReactivationData;
2031 }
2032
2033 CSuccessorConnectedNominalSet* CIndividualProcessNode::getSuccessorNominalConnectionSet(bool create) {
2034 CSuccessorConnectedNominalSet* nomConnSet = nullptr;
2035 if (!mLocNominalConnectionSet && create) {
2036 CSuccessorConnectedNominalSet* nomConnSet = CObjectParameterizingAllocator< CSuccessorConnectedNominalSet,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
2037 nomConnSet->initSuccessorConnectedNominalSet(mUseNominalConnectionSet);
2038 mLocNominalConnectionSet = nomConnSet;
2039 mUseNominalConnectionSet = nomConnSet;
2040 }
2041 return mUseNominalConnectionSet;
2042 }
2043
2044
2045 CSuccessorIndividualATMOSTReactivationData* CIndividualProcessNode::getSuccessorIndividualATMOSTReactivationData(bool create) {
2046 if (!mLocSuccIndiATMOSTReactivationData && create) {
2047 CSuccessorIndividualATMOSTReactivationData* succIndiATMOSTReactivationData = CObjectParameterizingAllocator< CSuccessorIndividualATMOSTReactivationData,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
2048 succIndiATMOSTReactivationData->initSuccessorIndividualATMOSTReactivationData(mUseSuccIndiATMOSTReactivationData);
2049 mLocSuccIndiATMOSTReactivationData = succIndiATMOSTReactivationData;
2050 mUseSuccIndiATMOSTReactivationData = succIndiATMOSTReactivationData;
2051 }
2052 return mUseSuccIndiATMOSTReactivationData;
2053 }
2054
2055
2056 bool CIndividualProcessNode::hasSuccessorConnectionToNominal(cint64 nominalID) {
2057 CSuccessorConnectedNominalSet* nomConnSet = getSuccessorNominalConnectionSet(false);
2058 if (nomConnSet) {
2059 return nomConnSet->hasSuccessorConnectedNominal(nominalID);
2060 }
2061 return false;
2062 }
2063
2064 bool CIndividualProcessNode::addSuccessorConnectionToNominal(cint64 nominalID) {
2065 CSuccessorConnectedNominalSet* nomConnSet = getSuccessorNominalConnectionSet(true);
2066 if (nomConnSet) {
2067 return nomConnSet->addSuccessorConnectedNominal(nominalID);
2068 }
2069 return false;
2070 }
2071
2072
2073
2074 CDatatypesValueSpaceData* CIndividualProcessNode::getDatatypesValueSpaceData(bool create) {
2075 CDatatypesValueSpaceData* valueSpaceData = nullptr;
2076 if (!mLocDatatypesValueSpaceData && create) {
2077 CDatatypesValueSpaceData* valueSpaceData = CObjectParameterizingAllocator< CDatatypesValueSpaceData,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
2078 valueSpaceData->initDatatypesValueSpaceData(mUseDatatypesValueSpaceData);
2079 mLocDatatypesValueSpaceData = valueSpaceData;
2080 mUseDatatypesValueSpaceData = valueSpaceData;
2081 }
2082 return mUseDatatypesValueSpaceData;
2083 }
2084
2085
2086
2087 CIndividualNodeIncrementalExpansionData* CIndividualProcessNode::getIncrementalExpansionData(bool create) {
2088 CIndividualNodeIncrementalExpansionData* incExpData = nullptr;
2089 if (!mLocIncExpData && create) {
2090 CIndividualNodeIncrementalExpansionData* incExpData = CObjectParameterizingAllocator< CIndividualNodeIncrementalExpansionData,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
2091 incExpData->initIncrementalExpansionData(mUseIncExpData);
2092 mLocIncExpData = incExpData;
2093 mUseIncExpData = incExpData;
2094 }
2095 return mUseIncExpData;
2096 }
2097
2098
2099 CIndividualMergingHash* CIndividualProcessNode::getIndividualMergingHash(bool create) {
2100 CIndividualMergingHash* indiMergHash = nullptr;
2101 if (!mLocIndividualMergingHash && create) {
2102 CIndividualMergingHash* indiMergHash = CObjectParameterizingAllocator< CIndividualMergingHash,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
2103 indiMergHash->initIndividualMergingHash(mUseIndividualMergingHash);
2104 mLocIndividualMergingHash = indiMergHash;
2105 mUseIndividualMergingHash = indiMergHash;
2106 }
2107 return mUseIndividualMergingHash;
2108 }
2109
2110
2111
2112
2113 CIndividualProcessNode* CIndividualProcessNode::getLastMergedIntoIndividualNode() {
2114 return mLastMergedIntoIndividualNode;
2115 }
2116
2117 CIndividualProcessNode* CIndividualProcessNode::setLastMergedIntoIndividualNode(CIndividualProcessNode* indiNode) {
2118 mLastMergedIntoIndividualNode = indiNode;
2119 return this;
2120 }
2121
2122
2123 CDependencyTrackPoint* CIndividualProcessNode::getMergedDependencyTrackPoint() {
2124 return mMergedDepTrackPoint;
2125 }
2126
2127 CIndividualProcessNode* CIndividualProcessNode::setMergedDependencyTrackPoint(CDependencyTrackPoint* depTrackPoint) {
2128 mMergedDepTrackPoint = depTrackPoint;
2129 return this;
2130 }
2131
2132
2133 CIndividualProcessNode* CIndividualProcessNode::setBlockerIndividualNode(CIndividualProcessNode* indiNode) {
2134 mBlockerIndiNode = indiNode;
2135 return this;
2136 }
2137
2138 CIndividualProcessNode* CIndividualProcessNode::getBlockerIndividualNode() {
2139 return mBlockerIndiNode;
2140 }
2141
2142 CIndividualProcessNode* CIndividualProcessNode::setFollowingIndividualNode(CIndividualProcessNode* indiNode) {
2143 mFollowingIndiNode = indiNode;
2144 return this;
2145 }
2146
2147 CIndividualProcessNode* CIndividualProcessNode::getFollowingIndividualNode() {
2148 return mFollowingIndiNode;
2149 }
2150
2151
2152 CIndividualProcessNode* CIndividualProcessNode::setIncrementalExpansionID(cint64 incExpID) {
2153 mIncExpID = incExpID;
2154 return this;
2155 }
2156
2157 cint64 CIndividualProcessNode::getIncrementalExpansionID() {
2158 return mIncExpID;
2159 }
2160
2161
2162 }; // end namespace Process
2163
2164 }; // end namespace Kernel
2165
2166 }; // end namespace Reasoner
2167
2168 }; // end namespace Konclude
2169