Debian Codegraph @

Source/Reasoner/Kernel/Process/CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData.h

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #ifndef KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALNODEREPRESENTATIVEMEMORYBACKENDCACHESYNCHRONISATIONDATA_H
22 #define KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALNODEREPRESENTATIVEMEMORYBACKENDCACHESYNCHRONISATIONDATA_H
23
24 // Libraries includes
25
26
27 // Namespace includes
28 #include "ProcessSettings.h"
29 #include "CIndividualNodeBackendCacheSynchronisationData.h"
30 #include "CConceptDescriptor.h"
31 #include "CProcessContext.h"
32 #include "CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationRoleNeighbourExpansionData.h"
33 #include "CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData.h"
34 #include "CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData.h"
35 #include "CBackendNeighbourExpansionQueue.h"
36
37 // Other includes
38 #include "Reasoner/Kernel/Cache/CBackendRepresentativeMemoryCacheIndividualAssociationData.h"
39
40
41 // Logger includes
42 #include "Logger/CLogger.h"
43
44
45
46 namespace Konclude {
47
48 namespace Reasoner {
49
50 namespace Kernel {
51
52 using namespace Cache;
53
54 namespace Process {
55
56 /*!
57 *
58 * \class CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData
59 * \author Andreas Steigmiller
60 * \version 0.1
61 * \brief TODO
62 *
63 */
64 class CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData : public CIndividualNodeBackendCacheSynchronisationData {
65 // public methods
66 public:
67 //! Constructor
68 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData(CProcessContext* context);
69
70 //! Destructor
71 virtual ~CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData();
72
73 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* initSynchronisationData(CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* synchData);
74 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* initSynchronisationData(CBackendRepresentativeMemoryCacheIndividualAssociationData* associationData);
75
76
77 CConceptDescriptor* getLastSynchronizationTestedConceptDescriptor();
78 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastSynchronizationTestedConceptDescriptor(CConceptDescriptor* conDes);
79
80 CIndividualLinkEdge* getLastCriticalCardinalityLinkEdge();
81 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastCriticalCardinalityLinkEdge(CIndividualLinkEdge* linkEdge);
82 bool hasCriticalCardinalityInitiallyChecked();
83 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setCriticalCardinalityInitiallyChecked(bool checked);
84
85
86 CConceptDescriptor* getLastCriticalNeighbourExpansionTestedConceptDescriptor();
87 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastCriticalNeighbourExpansionTestedConceptDescriptor(CConceptDescriptor* conDes);
88
89 CConceptDescriptor* getLastSynchedConceptDescriptor();
90 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastSynchedConceptDescriptor(CConceptDescriptor* conDes);
91
92 CBackendRepresentativeMemoryCacheIndividualAssociationData* getAssocitaionData();
93 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setAssociationData(CBackendRepresentativeMemoryCacheIndividualAssociationData* associationData);
94
95 bool isBackendCacheSynchron();
96 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setBackendCacheSynchron(bool synchron);
97
98 bool isCriticalNeighbourExpansionBlocking();
99 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setCriticalNeighbourExpansionBlocking(bool critical);
100
101 bool isCriticalCardinalityExpansionBlocking();
102 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setCriticalCardinalityExpansionBlocking(bool critical);
103
104
105 CConceptDescriptor* getLastNeighbourInfluenceTestedConceptDescriptor();
106 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastNeighbourInfluenceTestedConceptDescriptor(CConceptDescriptor* conDes);
107 CPROCESSHASH< QPair<CRole*, bool>, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationRoleNeighbourExpansionData >* getRoleNeighbourExpansionDataHash(bool createIfNotExists = true);
108 CPROCESSHASH< cint64, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData >* getNeighbourExpansionDataHash(bool createIfNotExists = true);
109 CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >* getNeighbourLabelExpansionDataHash(cint64 arrayId, bool createIfNotExists = true);
110 bool hasNeighbourInfluenceTestingCriticalCardinalityReset();
111 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* hasNeighbourInfluenceTestingCriticalCardinalityReset(bool reset);
112
113 cint64 getLastMergedIntoIndividualTestingCriticalCardinalityReset();
114 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastMergedIntoIndividualTestingCriticalCardinalityReset(cint64 indiId);
115
116
117
118 CIndividualLinkEdge* getLastNewNeighbourLinkEdge();
119 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastNewNeighbourLinkEdge(CIndividualLinkEdge* linkEdge);
120
121
122 bool hasNominalIndirectConnectionIndividualExpanded();
123 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNominalIndirectConnectionIndividualExpanded(bool expanded);
124
125
126 bool isCriticalIndirectConnectionIndividualExpansionBlocking();
127 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setCriticalIndirectConnectionIndividualExpansionBlocking(bool critical);
128
129 CIndividualLinkEdge* getLastIndirectConnectedIndividualExpansionTestedLinkEdge();
130 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastIndirectConnectedIndividualExpansionTestedLinkEdge(CIndividualLinkEdge* linkEdge);
131
132 CConceptDescriptor* getLastIndirectConnectedIndividualExpansionTestedConceptDescriptor();
133 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastIndirectConnectedIndividualExpansionTestedConceptDescriptor(CConceptDescriptor* conDes);
134
135 bool hasDeterministicSameIndividualMerged();
136 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setDeterministicSameIndividualMerged(bool merged);
137
138 bool hasDeterministicDifferentIndividualDifferentiated();
139 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setDeterministicDifferentIndividualDifferentiated(bool differentiated);
140
141
142
143
144 bool hasPrioritziedPropagationLinksEstablished();
145 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setPrioritziedPropagationLinksEstablished(bool established);
146
147
148
149 cint64 getLastMergedIndividualCount();
150 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastMergedIndividualCount(cint64 count);
151
152 CXLinker<cint64>* getLastProcessedMergedIndividualLinker();
153 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastProcessedMergedIndividualLinker(CXLinker<cint64>* indiLinker);
154
155
156 CPROCESSSET<cint64>* getIntegratedMergedIndividualIdSet(bool createIfNotExists = true);
157 CPROCESSSET<cint64>* getRemainingIndirectCompatibilityMergedIndividualCheckingSet(bool createIfNotExists = true);
158
159 CXLinker<CIndividualProcessNode*>* getMergedIndividualNodeLinker();
160 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* addMergedIndividualNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
161
162
163 CXLinker<CIndividualProcessNode*>* getLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker();
164 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
165
166 CXLinker<CIndividualProcessNode*>* getLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker();
167 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
168
169
170
171 CXLinker<CIndividualProcessNode*>* getLastSynchronizedConceptsTestedMergedNodeLinker();
172 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastSynchronizedConceptsTestedMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
173
174 CXLinker<CIndividualProcessNode*>* getLastCriticalNeighboursTestedMergedNodeLinker();
175 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastCriticalNeighboursTestedMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
176
177 CXLinker<CIndividualProcessNode*>* getLastDirectExpansionHandledMergedNodeLinker();
178 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastDirectExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
179
180 CXLinker<CIndividualProcessNode*>* getLastInferringExpansionHandledMergedNodeLinker();
181 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastInferringExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
182
183
184
185 CXLinker<CIndividualProcessNode*>* getLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker();
186 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
187
188
189 CXLinker<CIndividualProcessNode*>* getLastIndirectCompatibilityExpansionHandledMergedNodeLinker();
190 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastIndirectCompatibilityExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
191
192
193
194
195 bool hasMergedIndividualsAllNeighbourExpanded();
196 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setMergedIndividualsAllNeighbourExpanded(bool expanded);
197 bool hasMergedIndirectlyConnectedNominalIndividuals();
198 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setMergedIndirectlyConnectedNominalIndividuals(bool connection);
199
200 bool hasAllNeighbourExpansion();
201 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setAllNeighbourExpansion(bool expanded);
202 bool hasAllNeighbourForcedExpansion();
203 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setAllNeighbourForcedExpansion(bool expanded);
204
205
206 bool hasAllNeighbourExpansionScheduled();
207 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setAllNeighbourExpansionScheduled(bool expansionScheduled);
208 bool hasAllNeighbourForcedExpansionScheduled();
209 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setAllNeighbourForcedExpansionScheduled(bool expansionScheduled);
210
211
212
213 CXLinker<CIndividualProcessNode*>* getConceptSetLabelProcessedNodeLinker();
214 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setConceptSetLabelProcessedNodeLinker(CXLinker<CIndividualProcessNode*>* nodeLinker);
215
216
217
218 bool hasNonConceptSetBackendLabelRelatedProcessing();
219 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNonConceptSetBackendLabelRelatedProcessing(bool nonConceptSetRelatedProcessing);
220
221
222
223 bool hasNonConceptSetBackendNeighbourLabelRelatedProcessing();
224 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNonConceptSetBackendNeighbourLabelRelatedProcessing(bool nonConceptSetRelatedProcessing);
225
226
227 bool hasNeighbourLabelRepresentativeExpansion();
228 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNeighbourLabelRepresentativeExpansion(bool repExp);
229
230 bool hasNeighbourLabelRepresentativeExpansionInstalled();
231 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* installNeighbourLabelRepresentativeExpansion(CXLinker<CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData*>* linker);
232 CXLinker<CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData*>* getNeighbourLabelRepresentativeExpansionLinker();
233 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* clearNeighbourLabelRepresentativeExpansionLinker();
234
235
236
237 bool isBackendConceptSetInitialized();
238 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setBackendConceptSetInitialized(bool initialized);
239
240 bool isBackendConceptSetInitializationQueued();
241 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setBackendConceptSetInitializationQueued(bool queued);
242
243
244
245 bool isBackendConceptSetInitializationRequired();
246 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setBackendConceptSetInitializationRequired(bool initRequired);
247
248 bool isBackendConceptSetInitializationDelayingRegistered();
249 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setBackendConceptSetInitializationDelayingRegistered(bool registered);
250
251
252
253 CNonDeterministicDependencyTrackPoint* getBackendExpansionReuseDependencyTrackPoint();
254 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setBackendExpansionReuseDependencyTrackPoint(CNonDeterministicDependencyTrackPoint* depTrackPoint);
255
256 CXLinker<CIndividualProcessNode*>* getLastReuseExpansionHandledMergedNodeLinker();
257 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setLastReuseExpansionHandledMergedNodeLinker(CXLinker<CIndividualProcessNode*>* linker);
258
259 bool hasReuseNonDeterministicSameIndividualMerged();
260 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setReuseNonDeterministicSameIndividualMerged(bool merged);
261
262 bool hasReuseNonDeterministicDifferentIndividualStated();
263 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setReuseNonDeterministicDifferentIndividualStated(bool stated);
264
265 bool hasReuseNonDeterministicConceptsAdded();
266 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setReuseNonDeterministicConceptsAdded(bool added);
267
268 bool hasNewlyMergedIndividuals();
269 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNewlyMergedIndividuals(bool newlyMerged);
270
271 bool hasNonDeterministicallyMergedIndividuals();
272 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNonDeterministicallyMergedIndividuals(bool nonDeterministicallyMerged);
273
274 bool hasNewlyMergedAllNeighbourExpansion();
275 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNewlyMergedAllNeighbourExpansion(bool allExpanded);
276
277 bool hasNewlyMergedInferringNeighbourExpansion();
278 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setNewlyMergedInferringNeighbourExpansion(bool inferringExpanded);
279
280
281 CBackendNeighbourExpansionQueue* getBackendNeighbourExpansionQueue(bool create = true);
282 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* clearBackendNeighbourExpansionQueue();
283
284 CPROCESSHASH< CRole*, cint64 >* getRoleRepresentativeNeighbourCountHash(bool create = true);
285
286
287 bool isScheduledIndividual();
288 CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationData* setScheduledIndividual(bool scheduled);
289
290
291 // protected methods
292 protected:
293
294 // protected variables
295 protected:
296 CProcessContext* mContext;
297
298 CConceptDescriptor* mLastCriticalNeighbourTestedConDes;
299 CIndividualLinkEdge* mLastCriticalNeighbourLinkEdge;
300 bool mCriticalCardinalityInitiallyChecked;
301 CConceptDescriptor* mLastSynchronizationTestedConDes;
302 CConceptDescriptor* mLastSynchedConDes;
303 CBackendRepresentativeMemoryCacheIndividualAssociationData* mAssociationData;
304 bool mSynchron;
305 bool mCriticalNeighbour;
306 bool mCriticalCardinality;
307 bool mCriticalIndirectConnectedIndis;
308
309
310
311 CConceptDescriptor* mLastNeighbourInfluenceTestedConDes;
312 bool mNeighbourInfluenceTestingCriticalCardinalityReset;
313 CPROCESSHASH< QPair<CRole*, bool>, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationRoleNeighbourExpansionData >* mRoleNeighbourExpansionDataHash;
314 CPROCESSHASH< cint64, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationNeighbourExpansionData >* mNeighbourExpansionDataHash;
315 CPROCESSHASH< CBackendRepresentativeMemoryLabelCacheItem*, CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData >** mNeighbourLabelExpansionDataHashArray;
316
317 CPROCESSHASH< CRole*, cint64 >* mRoleRepNeighbourCountHash;
318
319
320 CXLinker<CIndividualProcessNode*>* mMergedIndiNodeLinker;
321 CPROCESSSET<cint64>* mRemainingIndirectCompatibilityMergedIndividualCheckingSet;
322 CPROCESSSET<cint64>* mIntegratedMergedIndividualIdSet;
323 bool mMergedIndividualsAllNeighbourExpanded;
324 bool mMergedIndirectlyConnectedNominalIndividuals;
325 bool mAllNeighbourExpansion;
326 bool mAllNeighbourForcedExpansion;
327 bool mAllNeighbourExpansionScheduled;
328 bool mAllNeighbourForcedExpansionScheduled;
329
330 CXLinker<CIndividualProcessNode*>* mLastIndirectlyConnectedNominalIndividualsHandledMergedNodeLinker;
331 CXLinker<CIndividualProcessNode*>* mLastIndirectlyConnectedNominalIndividualsTestedMergedNodeLinker;
332 CXLinker<CIndividualProcessNode*>* mLastSynchronizedConceptsTestedMergedNodeLinker;
333 CXLinker<CIndividualProcessNode*>* mLastCriticalNeighboursTestedMergedNodeLinker;
334 CXLinker<CIndividualProcessNode*>* mLastDirectExpansionHandledMergedNodeLinker;
335 CXLinker<CIndividualProcessNode*>* mLastInferringExpansionHandledMergedNodeLinker;
336 CXLinker<CIndividualProcessNode*>* mLastNewlyMergedExpansionRequiringCheckingMergedNodeLinker;
337 CXLinker<CIndividualProcessNode*>* mLastIndirectCompatibilityExpansionHandledMergedNodeLinker;
338
339 CIndividualLinkEdge* mLastNewNeighbourLinkEdge;
340
341
342 CConceptDescriptor* mLastIndirectConnectedIndiTestedConDes;
343 CIndividualLinkEdge* mIndirectConnectedIndiTestedLinkEdge;
344
345
346 bool mNewlyMergedIndividuals;
347 bool mDeterministicSameIndividualMerged;
348 bool mDeterministicDifferentIndividualDifferentiated;
349 bool mNomainlIndirectConnectionIndividualExpanded;
350 bool mPrioritziedPropagationLinksEstablished;
351
352
353 cint64 mLastMergedIndiCount;
354 CXLinker<cint64>* mLastProcessedMergedIndividualLinker;
355
356
357 CXLinker<CIndividualProcessNode*>* mConceptSetLabelProcessedIndiNodeLinker;
358
359 bool mNonConceptSetRelatedProcessing;
360 bool mBackendConceptSetInitialized;
361 bool mBackendConceptSetInitializationQueued;
362 bool mBackendConceptSetInitializationRequired;
363 bool mBackendConceptSetInitializationDelayingRegistered;
364
365
366 bool mNonConceptSetNeighbourLabelRelatedProcessing;
367 CXLinker<CIndividualNodeRepresentativeMemoryBackendCacheSynchronisationLabelNeighbourExpansionData*>* mNeighbourLabelRepresentativeExpansionLinker;
368 bool mNeighbourLabelRepresentativeExpansion;
369
370
371 CXLinker<CIndividualProcessNode*>* mDelayedAdditionalLinkInitializationLinker;
372
373 CNonDeterministicDependencyTrackPoint* mBackendExpansionReuseDependencyTrackPoint;
374 CXLinker<CIndividualProcessNode*>* mLastReuseExpansionHandledMergedNodeLinker;
375 bool mReuseNonDeterministicSameIndividualMerged;
376 bool mReuseNonDeterministicDifferentIndividualStated;
377 bool mReuseNonDeterministicConceptsAdded;
378
379
380 CBackendNeighbourExpansionQueue* mBackendNeighbourExpansionQueue;
381 CBackendNeighbourExpansionQueue* mPrevBackendNeighbourExpansion;
382 CBackendNeighbourExpansionQueue* mUseBackendNeighbourExpansion;
383
384
385 bool mNewlyMergedAllNeighbourExpansion;
386 bool mNewlyMergedInferringNeighbourExpansion;
387 bool mNonDeterministicallyMergedIndividuals;
388
389
390 cint64 mLastMergedIntoIndividualTestingCriticalCardinalityReset;
391
392 bool mScheduledIndividual;
393
394
395 // private methods
396 private:
397
398 // private variables
399 private:
400
401 };
402
403 }; // end namespace Process
404
405 }; // end namespace Kernel
406
407 }; // end namespace Reasoner
408
409 }; // end namespace Konclude
410
411 #endif // KONCLUDE_REASONER_KERNEL_PROCESS_CINDIVIDUALNODEREPRESENTATIVEMEMORYBACKENDCACHESYNCHRONISATIONDATA_H