Debian Codegraph @

Source/Reasoner/Kernel/Process/CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData.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 "CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Process {
31
32
33 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData(CProcessContext* context) {
34 mContext = context;
35 }
36
37
38 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::~CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData() {
39 }
40
41
42
43 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::initSynchronisationData(CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* synchData) {
44 mRoleNeighbourExpansionDataHash = nullptr;
45 mNeighbourExpansionDataHash = nullptr;
46 mNeighbourLabelExpansionDataHashArray = nullptr;
47 mIntegratedMergedIndividualIdSet = nullptr;
48 mRoleRepNeighbourCountHash = nullptr;
49 mRemainingIndirectCompatibilityMergedIndividualCheckingSet = nullptr;
50 if (synchData) {
51 mLastCriticalNeighbourTestedConDes = synchData->mLastCriticalNeighbourTestedConDes;
52 mLastSynchronizationTestedConDes = synchData->mLastSynchronizationTestedConDes;
53 mLastIndirectConnectedIndiTestedConDes = synchData->mLastIndirectConnectedIndiTestedConDes;
54 mLastSynchedConDes = synchData->mLastSynchedConDes;
55 mLastNeighbourInfluenceTestedConDes = synchData->mLastNeighbourInfluenceTestedConDes;
56 mNeighbourInfluenceTestingCriticalCardinalityReset = synchData->mNeighbourInfluenceTestingCriticalCardinalityReset;
57 mLastMergedIntoIndividualTestingCriticalCardinalityReset = synchData->mLastMergedIntoIndividualTestingCriticalCardinalityReset;
58 mAssociationData = synchData->mAssociationData;
59 mSynchron = synchData->mSynchron;
60 mCriticalNeighbour = synchData->mCriticalNeighbour;
61 mDeterministicSameIndividualMerged = synchData->mDeterministicSameIndividualMerged;
62 mDeterministicDifferentIndividualDifferentiated = synchData->mDeterministicDifferentIndividualDifferentiated;
63 mPrioritziedPropagationLinksEstablished = synchData->mPrioritziedPropagationLinksEstablished;
64 mCriticalIndirectConnectedIndis = synchData->mCriticalIndirectConnectedIndis;
65 mNomainlIndirectConnectionIndividualExpanded = synchData->mNomainlIndirectConnectionIndividualExpanded;
66 mLastCriticalNeighbourLinkEdge = synchData->mLastCriticalNeighbourLinkEdge;
67 mCriticalCardinalityInitiallyChecked = synchData->mCriticalCardinalityInitiallyChecked;
68 mLastNewNeighbourLinkEdge = synchData->mLastNewNeighbourLinkEdge;
69 mIndirectConnectedIndiTestedLinkEdge = synchData->mIndirectConnectedIndiTestedLinkEdge;
70 mCriticalCardinality = synchData->mCriticalCardinality;
71 mLastMergedIndiCount = synchData->mLastMergedIndiCount;
72 mLastProcessedMergedIndividualLinker = synchData->mLastProcessedMergedIndividualLinker;
73 mConceptSetLabelProcessedIndiNodeLinker = synchData->mConceptSetLabelProcessedIndiNodeLinker;
74 mNonConceptSetRelatedProcessing = synchData->mNonConceptSetRelatedProcessing;
75 mNonConceptSetNeighbourLabelRelatedProcessing = synchData->mNonConceptSetNeighbourLabelRelatedProcessing;
76 mNeighbourLabelRepresentativeExpansionLinker = synchData->mNeighbourLabelRepresentativeExpansionLinker;
77 mNeighbourLabelRepresentativeExpansion = synchData->mNeighbourLabelRepresentativeExpansion;
78 mBackendConceptSetInitialized = synchData->mBackendConceptSetInitialized;
79 mBackendConceptSetInitializationQueued = synchData->mBackendConceptSetInitializationQueued;
80 mBackendConceptSetInitializationRequired = synchData->mBackendConceptSetInitializationRequired;
81 mBackendConceptSetInitializationDelayingRegistered = synchData->mBackendConceptSetInitializationDelayingRegistered;
82 if (synchData->mRoleNeighbourExpansionDataHash) {
83 getRoleNeighbourExpansionDataHash()->init(synchData->mRoleNeighbourExpansionDataHash);
84 }
85 if (synchData->mNeighbourExpansionDataHash) {
86 getNeighbourExpansionDataHash()->init(synchData->mNeighbourExpansionDataHash);
87 }
88 if (synchData->mNeighbourLabelExpansionDataHashArray) {
89 cint64 arraySize = mAssociationData->getRoleSetNeighbourArray()->getIndexData()->getArraySize();
90 for (cint64 i = 0; i < arraySize; ++i) {
91 CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >* hash = synchData->mNeighbourLabelExpansionDataHashArray[i];
92 getNeighbourLabelExpansionDataHash(i, true)->init(hash);
93 }
94 }
95 if (synchData->mIntegratedMergedIndividualIdSet) {
96 getIntegratedMergedIndividualIdSet()->init(synchData->mIntegratedMergedIndividualIdSet);
97 }
98 if (synchData->mRemainingIndirectCompatibilityMergedIndividualCheckingSet) {
99 getRemainingIndirectCompatibilityMergedIndividualCheckingSet()->init(synchData->mRemainingIndirectCompatibilityMergedIndividualCheckingSet);
100 }
101 if (synchData->mRoleRepNeighbourCountHash) {
102 getRoleRepresentativeNeighbourCountHash(true)->init(synchData->mRoleRepNeighbourCountHash);
103 }
104 mMergedIndividualsAllNeighbourExpanded = synchData->mMergedIndividualsAllNeighbourExpanded;
105 mAllNeighbourExpansion = synchData->mAllNeighbourExpansion;
106 mAllNeighbourForcedExpansion = synchData->mAllNeighbourForcedExpansion;
107 mAllNeighbourExpansionScheduled = synchData->mAllNeighbourExpansionScheduled;
108 mAllNeighbourForcedExpansionScheduled = synchData->mAllNeighbourForcedExpansionScheduled;
109 mMergedIndirectlyConnectedNominalIndividuals = synchData->mMergedIndirectlyConnectedNominalIndividuals;
110 mMergedIndiNodeLinker = synchData->mMergedIndiNodeLinker;
111 mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker = synchData->mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker;
112 mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker = synchData->mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker;
113 mLastSynchronizedConceptsTestedMergedNodeLinker = synchData->mLastSynchronizedConceptsTestedMergedNodeLinker;
114 mLastCriticalNeighboursTestedMergedNodeLinker = synchData->mLastCriticalNeighboursTestedMergedNodeLinker;
115 mLastDirectExpansionHandledMergedNodeLinker = synchData->mLastDirectExpansionHandledMergedNodeLinker;
116 mLastInferringExpansionHandledMergedNodeLinker = synchData->mLastInferringExpansionHandledMergedNodeLinker;
117 mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker = synchData->mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker;
118 mLastReuseExpansionHandledMergedNodeLinker = synchData->mLastReuseExpansionHandledMergedNodeLinker;
119 mLastIndirectCompatibilityExpansionHandledMergedNodeLinker = synchData->mLastIndirectCompatibilityExpansionHandledMergedNodeLinker;
120 mBackendExpansionReuseDependencyTrackPoint = synchData->mBackendExpansionReuseDependencyTrackPoint;
121 mReuseNonDeterministicSameIndividualMerged = synchData->mReuseNonDeterministicSameIndividualMerged;
122 mReuseNonDeterministicDifferentIndividualStated = synchData->mReuseNonDeterministicDifferentIndividualStated;
123 mReuseNonDeterministicConceptsAdded = synchData->mReuseNonDeterministicConceptsAdded;
124 mUseBackendNeighbourExpansion = synchData->mUseBackendNeighbourExpansion;
125 mPrevBackendNeighbourExpansion = synchData->mUseBackendNeighbourExpansion;
126 mBackendNeighbourExpansionQueue = nullptr;
127 mNewlyMergedIndividuals = synchData->mNewlyMergedIndividuals;
128 mNewlyMergedAllNeighbourExpansion = synchData->mNewlyMergedAllNeighbourExpansion;
129 mNewlyMergedInferringNeighbourExpansion = synchData->mNewlyMergedInferringNeighbourExpansion;
130 mNonDeterministicallyMergedIndividuals = synchData->mNonDeterministicallyMergedIndividuals;
131 mScheduledIndividual = synchData->mScheduledIndividual;
132 } else {
133 mLastIndirectConnectedIndiTestedConDes = nullptr;
134 mLastSynchronizationTestedConDes = nullptr;
135 mLastCriticalNeighbourTestedConDes = nullptr;
136 mLastSynchedConDes = nullptr;
137 mLastNeighbourInfluenceTestedConDes = nullptr;
138 mNeighbourInfluenceTestingCriticalCardinalityReset = false;
139 mLastMergedIntoIndividualTestingCriticalCardinalityReset = -1;
140 mAssociationData = nullptr;
141 mLastCriticalNeighbourLinkEdge = nullptr;
142 mCriticalCardinalityInitiallyChecked = false;
143 mLastNewNeighbourLinkEdge = nullptr;
144 mIndirectConnectedIndiTestedLinkEdge = nullptr;
145 mSynchron = false;
146 mCriticalNeighbour = false;
147 mDeterministicSameIndividualMerged = false;
148 mDeterministicDifferentIndividualDifferentiated = false;
149 mPrioritziedPropagationLinksEstablished = false;
150 mCriticalIndirectConnectedIndis = false;
151 mNomainlIndirectConnectionIndividualExpanded = false;
152 mCriticalCardinality = false;
153 mRoleNeighbourExpansionDataHash = nullptr;
154 mNeighbourExpansionDataHash = nullptr;
155 mNeighbourLabelExpansionDataHashArray = nullptr;
156 mConceptSetLabelProcessedIndiNodeLinker = nullptr;
157 mLastProcessedMergedIndividualLinker = nullptr;
158 mLastMergedIndiCount = 0;
159 mNonConceptSetRelatedProcessing = false;
160 mNonConceptSetNeighbourLabelRelatedProcessing = false;
161 mNeighbourLabelRepresentativeExpansionLinker = nullptr;
162 mNeighbourLabelRepresentativeExpansion = false;
163 mBackendConceptSetInitialized = false;
164 mBackendConceptSetInitializationQueued = false;
165 mBackendConceptSetInitializationRequired = false;
166 mBackendConceptSetInitializationDelayingRegistered = false;
167 mMergedIndividualsAllNeighbourExpanded = false;
168 mAllNeighbourExpansion = false;
169 mAllNeighbourForcedExpansion = false;
170 mAllNeighbourExpansionScheduled = false;
171 mAllNeighbourForcedExpansionScheduled = false;
172 mMergedIndirectlyConnectedNominalIndividuals = false;
173 mMergedIndiNodeLinker = nullptr;
174 mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker = nullptr;
175 mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker = nullptr;
176 mLastSynchronizedConceptsTestedMergedNodeLinker = nullptr;
177 mRoleRepNeighbourCountHash = nullptr;
178 mLastCriticalNeighboursTestedMergedNodeLinker = nullptr;
179 mLastDirectExpansionHandledMergedNodeLinker = nullptr;
180 mLastInferringExpansionHandledMergedNodeLinker = nullptr;
181 mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker = nullptr;
182 mLastReuseExpansionHandledMergedNodeLinker = nullptr;
183 mLastIndirectCompatibilityExpansionHandledMergedNodeLinker = nullptr;
184 mBackendExpansionReuseDependencyTrackPoint = nullptr;
185 mReuseNonDeterministicSameIndividualMerged = false;
186 mReuseNonDeterministicDifferentIndividualStated = false;
187 mReuseNonDeterministicConceptsAdded = false;
188 mBackendNeighbourExpansionQueue = nullptr;
189 mUseBackendNeighbourExpansion = nullptr;
190 mPrevBackendNeighbourExpansion = nullptr;
191 mNewlyMergedIndividuals = false;
192 mNewlyMergedAllNeighbourExpansion = false;
193 mNewlyMergedInferringNeighbourExpansion = false;
194 mNonDeterministicallyMergedIndividuals = false;
195 mScheduledIndividual = false;
196 }
197 return this;
198 }
199
200
201 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::initSynchronisationData(CBackendRepresentativeMemoryCacheIndividualAssociationData* associationData) {
202 mLastIndirectConnectedIndiTestedConDes = nullptr;
203 mLastCriticalNeighbourTestedConDes = nullptr;
204 mLastSynchronizationTestedConDes = nullptr;
205 mLastSynchedConDes = nullptr;
206 mLastNeighbourInfluenceTestedConDes = nullptr;
207 mNeighbourInfluenceTestingCriticalCardinalityReset = false;
208 mLastMergedIntoIndividualTestingCriticalCardinalityReset = -1;
209 mCriticalCardinalityInitiallyChecked = false;
210 mLastCriticalNeighbourLinkEdge = nullptr;
211 mLastNewNeighbourLinkEdge = nullptr;
212 mIndirectConnectedIndiTestedLinkEdge = nullptr;
213 mAssociationData = associationData;
214 mSynchron = false;
215 mCriticalNeighbour = false;
216 mDeterministicSameIndividualMerged = false;
217 mDeterministicDifferentIndividualDifferentiated = false;
218 mPrioritziedPropagationLinksEstablished = false;
219 mCriticalIndirectConnectedIndis = false;
220 mNomainlIndirectConnectionIndividualExpanded = false;
221 mCriticalCardinality = false;
222 mRoleNeighbourExpansionDataHash = nullptr;
223 mNeighbourExpansionDataHash = nullptr;
224 mNeighbourLabelExpansionDataHashArray = nullptr;
225 mLastProcessedMergedIndividualLinker = nullptr;
226 mLastMergedIndiCount = 0;
227 mConceptSetLabelProcessedIndiNodeLinker = nullptr;
228 mNonConceptSetRelatedProcessing = false;
229 mNonConceptSetNeighbourLabelRelatedProcessing = false;
230 mNeighbourLabelRepresentativeExpansionLinker = nullptr;
231 mNeighbourLabelRepresentativeExpansion = false;
232 mBackendConceptSetInitialized = false;
233 mBackendConceptSetInitializationQueued = false;
234 mBackendConceptSetInitializationRequired = false;
235 mBackendConceptSetInitializationDelayingRegistered = false;
236 mIntegratedMergedIndividualIdSet = nullptr;
237 mMergedIndividualsAllNeighbourExpanded = false;
238 mAllNeighbourExpansion = false;
239 mAllNeighbourForcedExpansion = false;
240 mAllNeighbourExpansionScheduled = false;
241 mAllNeighbourForcedExpansionScheduled = false;
242 mMergedIndirectlyConnectedNominalIndividuals = false;
243 mMergedIndiNodeLinker = nullptr;
244 mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker = nullptr;
245 mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker = nullptr;
246 mLastSynchronizedConceptsTestedMergedNodeLinker = nullptr;
247 mRoleRepNeighbourCountHash = nullptr;
248 mLastCriticalNeighboursTestedMergedNodeLinker = nullptr;
249 mLastDirectExpansionHandledMergedNodeLinker = nullptr;
250 mLastInferringExpansionHandledMergedNodeLinker = nullptr;
251 mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker = nullptr;
252 mLastReuseExpansionHandledMergedNodeLinker = nullptr;
253 mLastIndirectCompatibilityExpansionHandledMergedNodeLinker = nullptr;
254 mRemainingIndirectCompatibilityMergedIndividualCheckingSet = nullptr;
255 mBackendExpansionReuseDependencyTrackPoint = nullptr;
256 mReuseNonDeterministicSameIndividualMerged = false;
257 mReuseNonDeterministicDifferentIndividualStated = false;
258 mReuseNonDeterministicConceptsAdded = false;
259 mBackendNeighbourExpansionQueue = nullptr;
260 mUseBackendNeighbourExpansion = nullptr;
261 mPrevBackendNeighbourExpansion = nullptr;
262 mNewlyMergedIndividuals = false;
263 mNewlyMergedAllNeighbourExpansion = false;
264 mNewlyMergedInferringNeighbourExpansion = false;
265 mNonDeterministicallyMergedIndividuals = false;
266 mScheduledIndividual = false;
267 return this;
268 }
269
270
271
272 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNewlyMergedIndividuals() {
273 return mNewlyMergedIndividuals;
274 }
275
276 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNewlyMergedIndividuals(bool newlyMerged) {
277 mNewlyMergedIndividuals = newlyMerged;
278 return this;
279 }
280
281
282
283 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNonDeterministicallyMergedIndividuals() {
284 return mNonDeterministicallyMergedIndividuals;
285 }
286
287 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNonDeterministicallyMergedIndividuals(bool nonDeterministicallyMerged) {
288 mNonDeterministicallyMergedIndividuals = nonDeterministicallyMerged;
289 return this;
290 }
291
292
293
294
295 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNewlyMergedAllNeighbourExpansion() {
296 return mNewlyMergedAllNeighbourExpansion;
297 }
298
299 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNewlyMergedAllNeighbourExpansion(bool allExpanded) {
300 mNewlyMergedAllNeighbourExpansion = allExpanded;
301 return this;
302 }
303
304
305 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNewlyMergedInferringNeighbourExpansion() {
306 return mNewlyMergedInferringNeighbourExpansion;
307 }
308
309 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNewlyMergedInferringNeighbourExpansion(bool inferringExpanded) {
310 mNewlyMergedInferringNeighbourExpansion = inferringExpanded;
311 return this;
312 }
313
314
315 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isCriticalCardinalityExpansionBlocking() {
316 return mCriticalCardinality;
317 }
318
319 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setCriticalCardinalityExpansionBlocking(bool critical) {
320 mCriticalCardinality = critical;
321 return this;
322 }
323
324
325 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isCriticalNeighbourExpansionBlocking() {
326 return mCriticalNeighbour;
327 }
328
329 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setCriticalNeighbourExpansionBlocking(bool critical) {
330 mCriticalNeighbour = critical;
331 return this;
332 }
333
334
335 CConceptDescriptor* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastSynchronizationTestedConceptDescriptor() {
336 return mLastSynchronizationTestedConDes;
337 }
338
339 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastSynchronizationTestedConceptDescriptor(CConceptDescriptor* conDes) {
340 mLastSynchronizationTestedConDes = conDes;
341 return this;
342 }
343
344
345 CIndividualLinkEdge* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastCriticalCardinalityLinkEdge() {
346 return mLastCriticalNeighbourLinkEdge;
347 }
348
349 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastCriticalCardinalityLinkEdge(CIndividualLinkEdge* linkEdge) {
350 mLastCriticalNeighbourLinkEdge = linkEdge;
351 return this;
352 }
353
354
355
356 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasCriticalCardinalityInitiallyChecked() {
357 return mCriticalCardinalityInitiallyChecked;
358 }
359
360 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setCriticalCardinalityInitiallyChecked(bool checked) {
361 mCriticalCardinalityInitiallyChecked = checked;
362 return this;
363 }
364
365
366
367
368 CIndividualLinkEdge* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastNewNeighbourLinkEdge() {
369 return mLastNewNeighbourLinkEdge;
370 }
371
372 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastNewNeighbourLinkEdge(CIndividualLinkEdge* linkEdge) {
373 mLastNewNeighbourLinkEdge = linkEdge;
374 return this;
375 }
376
377
378 CConceptDescriptor* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastCriticalNeighbourExpansionTestedConceptDescriptor() {
379 return mLastCriticalNeighbourTestedConDes;
380 }
381
382 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastCriticalNeighbourExpansionTestedConceptDescriptor(CConceptDescriptor* conDes) {
383 mLastCriticalNeighbourTestedConDes = conDes;
384 return this;
385 }
386
387
388
389 CConceptDescriptor* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastSynchedConceptDescriptor() {
390 return mLastSynchedConDes;
391 }
392
393 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastSynchedConceptDescriptor(CConceptDescriptor* conDes) {
394 mLastSynchedConDes = conDes;
395 return this;
396 }
397
398 CBackendRepresentativeMemoryCacheIndividualAssociationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getAssocitaionData() {
399 return mAssociationData;
400 }
401
402 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setAssociationData(CBackendRepresentativeMemoryCacheIndividualAssociationData* associationData) {
403 mAssociationData = associationData;
404 return this;
405 }
406
407
408 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isBackendCacheSynchron() {
409 return mSynchron;
410 }
411
412 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setBackendCacheSynchron(bool synchron) {
413 mSynchron = synchron;
414 return this;
415 }
416
417 CPROCESSHASH< QPair<CRole*, bool>, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationRoleNeighbourExpansionData >* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getRoleNeighbourExpansionDataHash(bool createIfNotExists) {
418 if (!mRoleNeighbourExpansionDataHash && createIfNotExists) {
419 mRoleNeighbourExpansionDataHash = CObjectParameterizingAllocator< CPROCESSHASH< QPair<CRole*, bool>, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationRoleNeighbourExpansionData >, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
420 }
421 return mRoleNeighbourExpansionDataHash;
422 }
423
424
425 CPROCESSHASH< cint64, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData >* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getNeighbourExpansionDataHash(bool createIfNotExists) {
426 if (!mNeighbourExpansionDataHash && createIfNotExists) {
427 mNeighbourExpansionDataHash = CObjectParameterizingAllocator< CPROCESSHASH< cint64, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData >, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
428 }
429 return mNeighbourExpansionDataHash;
430 }
431
432
433
434 CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getNeighbourLabelExpansionDataHash(cint64 arrayId, bool createIfNotExists) {
435 if (!mNeighbourLabelExpansionDataHashArray) {
436 cint64 arraySize = 0;
437 arraySize = mAssociationData->getRoleSetNeighbourArray()->getIndexData()->getArraySize();
438 mNeighbourLabelExpansionDataHashArray = CObjectAllocator< CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >* >::allocateAndConstructArray(mContext->getUsedMemoryAllocationManager(), arraySize);
439 }
440 CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >*& hash = mNeighbourLabelExpansionDataHashArray[arrayId];
441 if (!hash) {
442 hash = CObjectParameterizingAllocator< CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
443 }
444 return hash;
445 }
446
447
448
449
450 CPROCESSHASH< CRole*, cint64 >* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getRoleRepresentativeNeighbourCountHash(bool create) {
451 if (!mRoleRepNeighbourCountHash && create) {
452 mRoleRepNeighbourCountHash = CObjectParameterizingAllocator< CPROCESSHASH< CRole*, cint64 >, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
453 }
454 return mRoleRepNeighbourCountHash;
455 }
456
457
458
459 CConceptDescriptor* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastNeighbourInfluenceTestedConceptDescriptor() {
460 return mLastNeighbourInfluenceTestedConDes;
461 }
462
463 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastNeighbourInfluenceTestedConceptDescriptor(CConceptDescriptor* conDes) {
464 mLastNeighbourInfluenceTestedConDes = conDes;
465 return this;
466 }
467
468
469
470
471
472 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNeighbourInfluenceTestingCriticalCardinalityReset() {
473 return mNeighbourInfluenceTestingCriticalCardinalityReset;
474 }
475
476 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNeighbourInfluenceTestingCriticalCardinalityReset(bool reset) {
477 mNeighbourInfluenceTestingCriticalCardinalityReset = reset;
478 return this;
479 }
480
481
482 cint64 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastMergedIntoIndividualTestingCriticalCardinalityReset() {
483 return mLastMergedIntoIndividualTestingCriticalCardinalityReset;
484 }
485
486 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastMergedIntoIndividualTestingCriticalCardinalityReset(cint64 indiId) {
487 mLastMergedIntoIndividualTestingCriticalCardinalityReset = indiId;
488 return this;
489 }
490
491
492
493
494
495 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isCriticalIndirectConnectionIndividualExpansionBlocking() {
496 return mCriticalIndirectConnectedIndis;
497 }
498
499 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setCriticalIndirectConnectionIndividualExpansionBlocking(bool critical) {
500 mCriticalIndirectConnectedIndis = critical;
501 return this;
502 }
503
504
505
506
507 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNominalIndirectConnectionIndividualExpanded() {
508 return mNomainlIndirectConnectionIndividualExpanded;
509 }
510
511 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNominalIndirectConnectionIndividualExpanded(bool expanded) {
512 mNomainlIndirectConnectionIndividualExpanded = expanded;
513 return this;
514 }
515
516
517
518
519
520
521 CIndividualLinkEdge* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastIndirectConnectedIndividualExpansionTestedLinkEdge() {
522 return mIndirectConnectedIndiTestedLinkEdge;
523 }
524
525 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastIndirectConnectedIndividualExpansionTestedLinkEdge(CIndividualLinkEdge* linkEdge) {
526 mIndirectConnectedIndiTestedLinkEdge = linkEdge;
527 return this;
528 }
529
530
531 CConceptDescriptor* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastIndirectConnectedIndividualExpansionTestedConceptDescriptor() {
532 return mLastIndirectConnectedIndiTestedConDes;
533 }
534
535 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastIndirectConnectedIndividualExpansionTestedConceptDescriptor(CConceptDescriptor* conDes) {
536 mLastIndirectConnectedIndiTestedConDes = conDes;
537 return this;
538 }
539
540
541 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasDeterministicSameIndividualMerged() {
542 return mDeterministicSameIndividualMerged;
543 }
544
545 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setDeterministicSameIndividualMerged(bool merged) {
546 mDeterministicSameIndividualMerged = merged;
547 return this;
548 }
549
550
551 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasDeterministicDifferentIndividualDifferentiated() {
552 return mDeterministicDifferentIndividualDifferentiated;
553 }
554
555 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setDeterministicDifferentIndividualDifferentiated(bool differentiated) {
556 mDeterministicDifferentIndividualDifferentiated = differentiated;
557 return this;
558 }
559
560
561
562 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasPrioritziedPropagationLinksEstablished() {
563 return mPrioritziedPropagationLinksEstablished;
564 }
565
566 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setPrioritziedPropagationLinksEstablished(bool established) {
567 mPrioritziedPropagationLinksEstablished = established;
568 return this;
569 }
570
571
572
573 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getMergedIndividualNodeLinker() {
574 return mMergedIndiNodeLinker;
575 }
576
577 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::addMergedIndividualNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
578 mMergedIndiNodeLinker = linker->append(mMergedIndiNodeLinker);
579 return this;
580 }
581
582
583
584
585
586 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker() {
587 return mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker;
588 }
589
590 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
591 mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker = linker;
592 return this;
593 }
594
595
596
597 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker() {
598 return mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker;
599 }
600
601 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
602 mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker = linker;
603 return this;
604 }
605
606
607
608
609
610
611 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastSynchronizedConceptsTestedMergedNodeLinker() {
612 return mLastSynchronizedConceptsTestedMergedNodeLinker;
613 }
614
615 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastSynchronizedConceptsTestedMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
616 mLastSynchronizedConceptsTestedMergedNodeLinker = linker;
617 return this;
618 }
619
620
621 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastCriticalNeighboursTestedMergedNodeLinker() {
622 return mLastCriticalNeighboursTestedMergedNodeLinker;
623 }
624
625 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastCriticalNeighboursTestedMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
626 mLastCriticalNeighboursTestedMergedNodeLinker = linker;
627 return this;
628 }
629
630
631
632 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastDirectExpansionHandledMergedNodeLinker() {
633 return mLastDirectExpansionHandledMergedNodeLinker;
634 }
635
636 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastDirectExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
637 mLastDirectExpansionHandledMergedNodeLinker = linker;
638 return this;
639 }
640
641
642
643
644
645 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastInferringExpansionHandledMergedNodeLinker() {
646 return mLastInferringExpansionHandledMergedNodeLinker;
647 }
648
649 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastInferringExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
650 mLastInferringExpansionHandledMergedNodeLinker = linker;
651 return this;
652 }
653
654
655
656 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker() {
657 return mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker;
658 }
659
660 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
661 mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker = linker;
662 return this;
663 }
664
665
666
667
668
669 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastIndirectCompatibilityExpansionHandledMergedNodeLinker() {
670 return mLastIndirectCompatibilityExpansionHandledMergedNodeLinker;
671 }
672
673 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastIndirectCompatibilityExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
674 mLastIndirectCompatibilityExpansionHandledMergedNodeLinker = linker;
675 return this;
676 }
677
678
679
680
681
682 CPROCESSSET<cint64>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getIntegratedMergedIndividualIdSet(bool createIfNotExists) {
683 if (!mIntegratedMergedIndividualIdSet && createIfNotExists) {
684 mIntegratedMergedIndividualIdSet = CObjectParameterizingAllocator< CPROCESSSET<cint64>, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
685 }
686 return mIntegratedMergedIndividualIdSet;
687 }
688
689
690
691 CPROCESSSET<cint64>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getRemainingIndirectCompatibilityMergedIndividualCheckingSet(bool createIfNotExists) {
692 if (!mRemainingIndirectCompatibilityMergedIndividualCheckingSet && createIfNotExists) {
693 mRemainingIndirectCompatibilityMergedIndividualCheckingSet = CObjectParameterizingAllocator< CPROCESSSET<cint64>, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
694 }
695 return mRemainingIndirectCompatibilityMergedIndividualCheckingSet;
696 }
697
698
699 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasMergedIndividualsAllNeighbourExpanded() {
700 return mMergedIndividualsAllNeighbourExpanded;
701 }
702
703 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setMergedIndividualsAllNeighbourExpanded(bool expanded) {
704 mMergedIndividualsAllNeighbourExpanded = expanded;
705 return this;
706 }
707
708
709
710 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasMergedIndirectlyConnectedNominalIndividuals() {
711 return mMergedIndirectlyConnectedNominalIndividuals;
712 }
713
714 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setMergedIndirectlyConnectedNominalIndividuals(bool connection) {
715 mMergedIndirectlyConnectedNominalIndividuals = connection;
716 return this;
717 }
718
719
720
721 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasAllNeighbourExpansion() {
722 return mAllNeighbourExpansion;
723 }
724
725 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setAllNeighbourExpansion(bool expanded) {
726 mAllNeighbourExpansion = expanded;
727 return this;
728 }
729
730
731 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasAllNeighbourForcedExpansion() {
732 return mAllNeighbourForcedExpansion;
733 }
734
735 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setAllNeighbourForcedExpansion(bool expanded) {
736 mAllNeighbourForcedExpansion = expanded;
737 return this;
738 }
739
740
741
742
743
744
745
746 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasAllNeighbourExpansionScheduled() {
747 return mAllNeighbourExpansionScheduled;
748 }
749
750 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setAllNeighbourExpansionScheduled(bool expansionScheduled) {
751 mAllNeighbourExpansionScheduled = expansionScheduled;
752 return this;
753 }
754
755
756 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasAllNeighbourForcedExpansionScheduled() {
757 return mAllNeighbourForcedExpansionScheduled;
758 }
759
760 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setAllNeighbourForcedExpansionScheduled(bool expansionScheduled) {
761 mAllNeighbourForcedExpansionScheduled = expansionScheduled;
762 return this;
763 }
764
765
766
767
768
769
770
771 cint64 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastMergedIndividualCount() {
772 return mLastMergedIndiCount;
773 }
774
775 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastMergedIndividualCount(cint64 count) {
776 mLastMergedIndiCount = count;
777 return this;
778 }
779
780
781 CXLinker<cint64>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastProcessedMergedIndividualLinker() {
782 return mLastProcessedMergedIndividualLinker;
783 }
784
785 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastProcessedMergedIndividualLinker(CXLinker<cint64>* indiLinker) {
786 mLastProcessedMergedIndividualLinker = indiLinker;
787 return this;
788 }
789
790
791
792 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getConceptSetLabelProcessedNodeLinker() {
793 return mConceptSetLabelProcessedIndiNodeLinker;
794 }
795
796
797 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setConceptSetLabelProcessedNodeLinker(CXLinker<CIndividualProcessNode*>* nodeLinker) {
798 mConceptSetLabelProcessedIndiNodeLinker = nodeLinker;
799 return this;
800 }
801
802
803 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNonConceptSetBackendLabelRelatedProcessing() {
804 return mNonConceptSetRelatedProcessing;
805 }
806
807 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNonConceptSetBackendLabelRelatedProcessing(bool nonConceptSetRelatedProcessing) {
808 mNonConceptSetRelatedProcessing = nonConceptSetRelatedProcessing;
809 return this;
810 }
811
812
813
814 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNonConceptSetBackendNeighbourLabelRelatedProcessing() {
815 return mNonConceptSetNeighbourLabelRelatedProcessing;
816 }
817
818 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNonConceptSetBackendNeighbourLabelRelatedProcessing(bool nonConceptSetRelatedProcessing) {
819 mNonConceptSetNeighbourLabelRelatedProcessing = nonConceptSetRelatedProcessing;
820 return this;
821 }
822
823
824
825
826 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNeighbourLabelRepresentativeExpansionInstalled() {
827 return mNeighbourLabelRepresentativeExpansionLinker != nullptr;
828 }
829
830 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::installNeighbourLabelRepresentativeExpansion(CXLinker<CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData*>* linker) {
831 mNeighbourLabelRepresentativeExpansionLinker = linker->append(mNeighbourLabelRepresentativeExpansionLinker);
832 return this;
833 }
834
835 CXLinker<CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getNeighbourLabelRepresentativeExpansionLinker() {
836 return mNeighbourLabelRepresentativeExpansionLinker;
837 }
838
839 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::clearNeighbourLabelRepresentativeExpansionLinker() {
840 mNeighbourLabelRepresentativeExpansionLinker = nullptr;
841 return this;
842 }
843
844
845
846
847
848 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasNeighbourLabelRepresentativeExpansion() {
849 return mNeighbourLabelRepresentativeExpansion;
850 }
851
852 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setNeighbourLabelRepresentativeExpansion(bool repExp) {
853 mNeighbourLabelRepresentativeExpansion = repExp;
854 return this;
855 }
856
857
858
859
860
861
862
863
864 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isBackendConceptSetInitialized() {
865 return mBackendConceptSetInitialized;
866 }
867
868 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setBackendConceptSetInitialized(bool initialized) {
869 mBackendConceptSetInitialized = initialized;
870 return this;
871 }
872
873
874 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isBackendConceptSetInitializationQueued() {
875 return mBackendConceptSetInitializationQueued;
876 }
877
878 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setBackendConceptSetInitializationQueued(bool queued) {
879 mBackendConceptSetInitializationQueued = queued;
880 return this;
881 }
882
883
884 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isBackendConceptSetInitializationRequired() {
885 return mBackendConceptSetInitializationRequired;
886 }
887
888 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setBackendConceptSetInitializationRequired(bool initRequired) {
889 mBackendConceptSetInitializationRequired = initRequired;
890 return this;
891 }
892
893
894 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isBackendConceptSetInitializationDelayingRegistered() {
895 return mBackendConceptSetInitializationDelayingRegistered;
896 }
897
898 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setBackendConceptSetInitializationDelayingRegistered(bool registered) {
899 mBackendConceptSetInitializationDelayingRegistered = registered;
900 return this;
901 }
902
903 CNonDeterministicDependencyTrackPoint* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getBackendExpansionReuseDependencyTrackPoint() {
904 return mBackendExpansionReuseDependencyTrackPoint;
905 }
906
907 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setBackendExpansionReuseDependencyTrackPoint(CNonDeterministicDependencyTrackPoint* depTrackPoint) {
908 mBackendExpansionReuseDependencyTrackPoint = depTrackPoint;
909 return this;
910 }
911
912
913
914
915 CXLinker<CIndividualProcessNode*>* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getLastReuseExpansionHandledMergedNodeLinker() {
916 return mLastReuseExpansionHandledMergedNodeLinker;
917 }
918
919 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setLastReuseExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker) {
920 mLastReuseExpansionHandledMergedNodeLinker = linker;
921 return this;
922 }
923
924 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasReuseNonDeterministicSameIndividualMerged() {
925 return mReuseNonDeterministicSameIndividualMerged;
926 }
927
928 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setReuseNonDeterministicSameIndividualMerged(bool merged) {
929 mReuseNonDeterministicSameIndividualMerged = merged;
930 return this;
931 }
932
933 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasReuseNonDeterministicDifferentIndividualStated() {
934 return mReuseNonDeterministicDifferentIndividualStated;
935 }
936
937 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setReuseNonDeterministicDifferentIndividualStated(bool stated) {
938 mReuseNonDeterministicDifferentIndividualStated = stated;
939 return this;
940 }
941
942 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::hasReuseNonDeterministicConceptsAdded() {
943 return mReuseNonDeterministicConceptsAdded;
944 }
945
946 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setReuseNonDeterministicConceptsAdded(bool added) {
947 mReuseNonDeterministicConceptsAdded = added;
948 return this;
949 }
950
951
952 bool CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::isScheduledIndividual() {
953 return mScheduledIndividual;
954 }
955
956 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::setScheduledIndividual(bool scheduled) {
957 mScheduledIndividual = scheduled;
958 return this;
959 }
960
961
962 CBackendNeighbourExpansionQueue* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::getBackendNeighbourExpansionQueue(bool create) {
963 if (!mBackendNeighbourExpansionQueue && create) {
964 mBackendNeighbourExpansionQueue = CObjectParameterizingAllocator< CBackendNeighbourExpansionQueue, CProcessContext* >::allocateAndConstructAndParameterize(mContext->getUsedMemoryAllocationManager(), mContext);
965 mBackendNeighbourExpansionQueue->initBackendNeighbourExpansionQueue(mPrevBackendNeighbourExpansion);
966 mUseBackendNeighbourExpansion = mBackendNeighbourExpansionQueue;
967 }
968 return mUseBackendNeighbourExpansion;
969 }
970
971
972 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData::clearBackendNeighbourExpansionQueue() {
973 mBackendNeighbourExpansionQueue = nullptr;
974 mUseBackendNeighbourExpansion = nullptr;
975 mPrevBackendNeighbourExpansion = nullptr;
976 return this;
977 }
978
979 }; // end namespace Process
980
981 }; // end namespace Kernel
982
983 }; // end namespace Reasoner
984
985 }; // end namespace Konclude