Debian Codegraph @

Source/Reasoner/Consistiser/CTotallyOntologyPrecomputationItem.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 "CTotallyOntologyPrecomputationItem.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Consistiser {
29
30
31 CTotallyOntologyPrecomputationItem::CTotallyOntologyPrecomputationItem() {
32 }
33
34 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::initTotallyPrecomputationItem(CConcreteOntology* ontology, CConfigurationBase* config) {
35 COntologyPrecomputationItem::initPrecomputationItem(ontology,config);
36 mConsistenceCheched = false;
37 mConsistence = nullptr;
38 mPrecomputation = ontology->getPrecomputation();
39 mCalculationConfig = new CCalculationConfigurationExtension(config,0);
40 mConsistenceCheckCreated = false;
41 mConceptCyclePrecomputationChecked = false;
42 mConceptCyclePrecomputationInitialized = false;
43 mMinConceptCycleTestSize = 0;
44 mConceptSaturationPrecomputationChecked = false;
45 mConceptSaturationPrecomputationCreated = false;
46 mSaturationTestRunning = false;
47 mIndividualPrecomputationCreated = false;
48 mIndividualPrecomputationChecked = false;
49 mIndividualPrecomputationClashed = false;
50 mIndividualPrecomputationExpansionLimitedReachedPointer = false;
51
52 mRemainingABoxIndiSatLinker = nullptr;
53
54 COntologyProcessingStepDataVector* ontProStepDataVec = mOntology->getProcessingSteps()->getOntologyProcessingStepDataVector();
55
56 mConsistencePrecomputationStep = new CPrecomputationTestingStep(CPrecomputationTestingStep::CONSISTENCYPRECOMPUTATIONSTEP,ontProStepDataVec->getProcessingStepData(COntologyProcessingStep::OPSCONSISTENCY),this);
57 mCyclePrecomputationStep = new CPrecomputationTestingStep(CPrecomputationTestingStep::CYCLEPRECOMPUTATIONSTEP,ontProStepDataVec->getProcessingStepData(COntologyProcessingStep::OPSPRECOMPUTECYCLES),this);
58 mOccurrenceStatisticsPrecomputationStep = new CPrecomputationTestingStep(CPrecomputationTestingStep::OCCURRENCESTATISTICSPRECOMPUTATIONSTEP, ontProStepDataVec->getProcessingStepData(COntologyProcessingStep::OPSPRECOMPUTEOCCURRENCESTATISTICS), this);
59
60 mSaturationPrecomputationStep = new CPrecomputationTestingStep(CPrecomputationTestingStep::SATURATIONPRECOMPUTATIONSTEP,ontProStepDataVec->getProcessingStepData(COntologyProcessingStep::OPSPRECOMPUTESATURATION),this);
61 mIndividualPrecomputationStep = new CPrecomputationTestingStep(CPrecomputationTestingStep::INDIVIDUALPRECOMPUTATIONSTEP,ontProStepDataVec->getProcessingStepData(COntologyProcessingStep::OPSPRECOMPUTEINDIVIDUAL),this);
62 mProcessingSteps.append(mCyclePrecomputationStep);
63 mProcessingSteps.append(mOccurrenceStatisticsPrecomputationStep);
64 mProcessingSteps.append(mConsistencePrecomputationStep);
65 mProcessingSteps.append(mSaturationPrecomputationStep);
66 mProcessingSteps.append(mIndividualPrecomputationStep);
67
68 mApproxSatCalcJob = nullptr;
69 mLastSaturData = nullptr;
70 mAllConSatRequired = false;
71 mAllConSatOrdered = false;
72 mNomDelayedConSatUpRequired = false;
73 mNomDelayedConSatUpdated = false;
74 mSaturationComputationRunning = false;
75 mIndividualComputationRunning = false;
76
77 mAllAssertionIndividual = nullptr;
78 mAllAssertionIndividualSaturated = false;
79 mAllAssertionIndividualSufficientSaturationChecked = false;
80 mAllAssertionIndividualSaturationSufficient = false;
81
82 mIndividualSaturationClashed = false;
83 mIndividualSaturationInsufficient = false;
84 mIndividualSaturated = false;
85 mAllIndividualSaturaturationOrderd = false;
86
87 mIndividualSaturationRunningCount = 0;
88 mRemainingRequiredABoxSaturationIndividualCount = 0;
89
90 mFreeItemLinker = nullptr;
91 mNextSaturationID = 1;
92 mIndividualTestRunning = false;
93 mIndividualsSaturationCacheSynchronisation = false;
94 mIndividualsSaturationAllOrderedCacheRetrieved = false;
95 mTriplesIndexedIndisSaturated = false;
96
97 mHandledTriplesIndiSaturatedId = -1;
98
99 mRemainingIncompletelyHandlingIndividualComputationLimitIncreasingCount = 0;
100
101 mAllIncompIndiRetrieved = false;
102 mFirstIncompletelyHandledIndividualsRetrieved = false;
103 mCurrentIncompIndiRetrievalLimit = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.PrecompuationRequiredIndividualRetrievalSize", 100000);
104 mCurrentIncompIndiRetrievalThresholdFactor = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.PrecompuationRequiredIndividualRetrievalThresholdPercent", 50) / 100.;
105 mIncompletelyHandlingIndividualComputationLimitIncreasingFactor = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.IndividualsPrecompuationLimitIncreasingFactorPercent", 101) / 100.;
106 mCurrentIncompIndiRetrievalThreshold = mCurrentIncompIndiRetrievalLimit * mCurrentIncompIndiRetrievalThresholdFactor;
107 mCurrentIncompIndiComputationLimit = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.IndividualsPrecompuationSize", 1500);
108 mIndividualSaturationCount = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.IndividualsSaturationSize", 3000);
109 cint64 ontoSizeIncreaseFactor = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.IndividualsHandlingCountOntologySizeIncreaseFactor", 500000);
110 cint64 ontoSizeMaxIncreaseFactor = CConfigDataReader::readConfigInteger(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.IndividualsHandlingCountOntologySizeMaxIncreaseFactor", -1);
111
112 mRecomputationExpansionPropagationCuttedReductionIncreaseFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.ExpansionPropagationCutIndividualsPrecompuationSizeReductionFactor", 0.01);
113 mRecomputationExpansionPropagationCuttedReductionRecoveryFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.ExpansionPropagationCutIndividualsPrecompuationSizeReductionRecoveryFactor", 0.0005);
114 mMaximumRecomputationExpansionPropagationCuttedReductionFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.ExpansionPropagationCutIndividualsPrecompuationSizeMaximumReductionFactor", 0.90);
115 mCurrentRecomputationExpansionPropagationCuttedReductionFactor = 0;
116
117 cint64 indiCount = ontology->getABox()->getIndividualCount();
118 if (indiCount > ontoSizeIncreaseFactor) {
119 double factor = (double)indiCount / (double)ontoSizeIncreaseFactor;
120 if (ontoSizeMaxIncreaseFactor >= 0) {
121 factor = qMin((double)ontoSizeMaxIncreaseFactor, factor);
122 }
123 mIndividualSaturationCount *= factor;
124 mCurrentIncompIndiRetrievalThresholdFactor *= factor;
125 mCurrentIncompIndiRetrievalThreshold *= factor;
126 mCurrentIncompIndiComputationLimit *= factor;
127 mCurrentIncompIndiRetrievalLimit *= factor;
128 }
129 mIncompletelyHandledIndividualComputationPropagationCutReservedSize = 0;
130 mLastMinRetrievedIncompIndiId = -1;
131
132 mIndividualComputationRunningCount = 0;
133
134 mCurrentIndiCompCoordHash = nullptr;
135
136 mFullCompletionGraphConstruction = false;
137 mFullCompletionGraphConstructed = false;
138 mForceCompletionGraphConstruction = false;
139
140 mSaturationOccurrenceStatisticsCollectingInitialized = false;
141 mSaturationOccurrenceStatisticsCollected = false;
142
143 mPrecompuationIncompletelyHandledIndividualsRetrievalThresholdRequested = false;
144 mPrecompuationRetrievingIncompletelyHandledIndividuals = false;
145 mPrecomputationProcessingCoordinationHash = nullptr;
146 mPrecomputationRetrievalCoordinationHash = nullptr;
147
148 mIndividualSaturationTime = nullptr;
149 mIndividualPrecomputationTime = nullptr;
150
151 mFailAfterConsistencyConceptSaturation = CConfigDataReader::readConfigBoolean(config,"Konclude.Debug.FailAfterConsistencyConceptSaturation",false);
152 mFailAfterConsistencyChecking = CConfigDataReader::readConfigBoolean(config,"Konclude.Debug.FailAfterConsistencyCheck",false);
153 mFailAfterConceptSaturation = CConfigDataReader::readConfigBoolean(config,"Konclude.Debug.FailAfterConceptSaturation",false);
154
155 mHadBasicPrecompuationMode = false;
156 mBasicPrecompuationSubsequentIndividualLimitReductionFactor = 1.;
157 mBasicPrecompuationSubsequentIndividualLimitReductionInitializationFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.BasicPrecompuationSubsequentIndividualLimitReductionInitializationFactor", 0.005);
158 mBasicPrecompuationSubsequentIndividualLimitReductionIncreasingFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.BasicPrecompuationSubsequentIndividualLimitReductionIncreasingFactor", 1.01);
159
160
161 mBasicPrecompuationParallelizationInitializationFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.BasicPrecompuationParallelizationInitializationFactor", 1);
162 mBasicPrecompuationParallelizationIncreasingFactor = CConfigDataReader::readConfigDouble(config, "Konclude.Calculation.Precomputation.TotalPrecomputor.BasicPrecompuationParallelizationIncreasingFactor", 1.01);
163 mBasicPrecompuationParallelizationReductionFactor = -1;
164
165 mNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize = 0;
166
167 mMaxHandledRecomputationIdRemainingReporting = 50;
168
169 mInitTime.start();
170 return this;
171 }
172
173
174
175
176 CTotallyOntologyPrecomputationItem::~CTotallyOntologyPrecomputationItem() {
177 delete mCalculationConfig;
178 delete mConsistencePrecomputationStep;
179 delete mCyclePrecomputationStep;
180 delete mOccurrenceStatisticsPrecomputationStep;
181 delete mSaturationPrecomputationStep;
182 delete mIndividualPrecomputationStep;
183
184 if (mAllAssertionIndividual) {
185 CConceptAssertionLinker* conAssLinker = mAllAssertionIndividual->getAssertionConceptLinker();
186 while (conAssLinker) {
187 CConceptAssertionLinker* tmpConAssLinker = conAssLinker;
188 conAssLinker = conAssLinker->getNext();
189 delete tmpConAssLinker;
190 }
191
192 CRoleAssertionLinker* roleAssLinker = mAllAssertionIndividual->getAssertionRoleLinker();
193 while (roleAssLinker) {
194 CRoleAssertionLinker* tmpRoleAssLinker = roleAssLinker;
195 roleAssLinker = roleAssLinker->getNext();
196 delete tmpRoleAssLinker;
197 }
198 delete mAllAssertionIndividual;
199 }
200 }
201
202
203
204
205 bool CTotallyOntologyPrecomputationItem::failAfterConsistencyConceptSaturation() {
206 return mFailAfterConsistencyConceptSaturation;
207 }
208
209 bool CTotallyOntologyPrecomputationItem::failAfterConsistencyChecking() {
210 return mFailAfterConsistencyChecking;
211 }
212
213 bool CTotallyOntologyPrecomputationItem::failAfterConceptSaturation() {
214 return mFailAfterConceptSaturation;
215 }
216
217
218 cint64 CTotallyOntologyPrecomputationItem::getNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize() {
219 return mNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize;
220 }
221
222 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize(bool straekSize) {
223 mNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize = straekSize;
224 return this;
225 }
226
227 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::incNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize(bool incStreakSize) {
228 mNonPrecompuationDirectIncompletelyHandledIndividualsRetrievingStreakSize += incStreakSize;
229 return this;
230 }
231
232
233 COntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addPrecomputationRequirement(COntologyProcessingRequirement* ontoRequirement) {
234 bool supportRequirement = false;
235 COntologyProcessingStepRequirement* stepProcRequirement = dynamic_cast<COntologyProcessingStepRequirement*>(ontoRequirement);
236 if (stepProcRequirement) {
237 if (stepProcRequirement->getRequiredProcessingStep()->getOntologyProcessingType() == COntologyProcessingStep::OPSCONSISTENCY) {
238 mConsistencePrecomputationStep->addProcessingRequirement(stepProcRequirement);
239 supportRequirement = true;
240 }
241 if (stepProcRequirement->getRequiredProcessingStep()->getOntologyProcessingType() == COntologyProcessingStep::OPSPRECOMPUTESATURATION) {
242 mSaturationPrecomputationStep->addProcessingRequirement(stepProcRequirement);
243 mAllConSatRequired = true;
244 supportRequirement = true;
245 }
246 if (stepProcRequirement->getRequiredProcessingStep()->getOntologyProcessingType() == COntologyProcessingStep::OPSPRECOMPUTECYCLES) {
247 mCyclePrecomputationStep->addProcessingRequirement(stepProcRequirement);
248 supportRequirement = true;
249 }
250 if (stepProcRequirement->getRequiredProcessingStep()->getOntologyProcessingType() == COntologyProcessingStep::OPSPRECOMPUTEOCCURRENCESTATISTICS) {
251 mOccurrenceStatisticsPrecomputationStep->addProcessingRequirement(stepProcRequirement);
252 supportRequirement = true;
253 }
254 if (stepProcRequirement->getRequiredProcessingStep()->getOntologyProcessingType() == COntologyProcessingStep::OPSPRECOMPUTEINDIVIDUAL) {
255 mIndividualPrecomputationStep->addProcessingRequirement(stepProcRequirement);
256 supportRequirement = true;
257 }
258 }
259 COntologyProcessingConceptSaturationRequirement* conSatRequirement = dynamic_cast<COntologyProcessingConceptSaturationRequirement*>(ontoRequirement);
260 if (conSatRequirement) {
261 addRequiredSaturationConcept(conSatRequirement->getConcept(),conSatRequirement->getConceptNegation());
262 mSaturationPrecomputationStep->addProcessingRequirement(conSatRequirement);
263 supportRequirement = true;
264 }
265
266 if (!supportRequirement) {
267 stepProcRequirement->submitRequirementUpdate(COntologyProcessingStatus::PSCOMPLETELYYPROCESSED, COntologyProcessingStatus::PSFAILED | COntologyProcessingStatus::PSUNSUPPORTED);
268 }
269 return this;
270 }
271
272
273
274 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConsistenceCheched(bool consistenceChecked) {
275 mConsistenceCheched = consistenceChecked;
276 return this;
277 }
278
279 bool CTotallyOntologyPrecomputationItem::hasConsistenceCheched() {
280 return mConsistenceCheched;
281 }
282
283
284 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConsistenceCheckCreated(bool consistenceCheckCreated) {
285 mConsistenceCheckCreated = consistenceCheckCreated;
286 return this;
287 }
288
289 bool CTotallyOntologyPrecomputationItem::hasConsistenceCheckCreated() {
290 return mConsistenceCheckCreated;
291 }
292
293
294 CConsistenceObserver* CTotallyOntologyPrecomputationItem::tellConsistenceData(CConsistenceData* consData) {
295 if (mConsData.testAndSetOrdered(nullptr,consData)) {
296 consData->overtakeData();
297 } else {
298 delete consData;
299 }
300 return this;
301 }
302
303
304
305 CSaturationObserver* CTotallyOntologyPrecomputationItem::tellSaturationData(CSaturationData* saturationData) {
306 //if (mSaturData.testAndSetOrdered(nullptr,saturationData)) {
307 // saturationData->overtakeData();
308 //} else {
309 // delete saturationData;
310 //}
311 saturationData->overtakeData();
312 mSaturDataAddMutex.lock();
313 mLastSaturData = saturationData;
314 mSaturDataList.append(mLastSaturData);
315 mSaturDataAddMutex.unlock();
316 return this;
317 }
318
319 CSaturationData* CTotallyOntologyPrecomputationItem::getSaturationData() {
320 return mLastSaturData;
321 }
322
323
324
325 CConsistenceData* CTotallyOntologyPrecomputationItem::getConsistenceData() {
326 return mConsData.fetchAndAddRelaxed(0);
327 }
328
329
330 CConsistence* CTotallyOntologyPrecomputationItem::getConsistence() {
331 return mConsistence;
332 }
333
334
335 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConsistence(CConsistence* consistence) {
336 mConsistence = consistence;
337 return this;
338 }
339
340 CCalculationConfigurationExtension* CTotallyOntologyPrecomputationItem::getCalculationConfiguration() {
341 return mCalculationConfig;
342 }
343
344 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecomputation(CPrecomputation* precomputation) {
345 mPrecomputation = precomputation;
346 return this;
347 }
348 CPrecomputation* CTotallyOntologyPrecomputationItem::getPrecomputation() {
349 return mPrecomputation;
350 }
351
352 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConceptCyclePrecomputationInitialized(bool initialized) {
353 mConceptCyclePrecomputationInitialized = initialized;
354 return this;
355 }
356
357 bool CTotallyOntologyPrecomputationItem::hasConceptCyclePrecomputationInitialized() {
358 return mConceptCyclePrecomputationInitialized;
359 }
360
361
362 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConceptCyclePrecomputationChecked(bool checked) {
363 mConceptCyclePrecomputationChecked = checked;
364 return this;
365 }
366
367 bool CTotallyOntologyPrecomputationItem::hasConceptCyclePrecomputationChecked() {
368 return mConceptCyclePrecomputationChecked;
369 }
370
371 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConceptSaturationPrecomputationCreated(bool initialized) {
372 mConceptSaturationPrecomputationCreated = initialized;
373 return this;
374 }
375
376 bool CTotallyOntologyPrecomputationItem::hasConceptSaturationPrecomputationCreated() {
377 return mConceptSaturationPrecomputationCreated;
378 }
379
380
381 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setConceptSaturationPrecomputationChecked(bool checked) {
382 mConceptSaturationPrecomputationChecked = checked;
383 return this;
384 }
385
386 bool CTotallyOntologyPrecomputationItem::hasConceptSaturationPrecomputationChecked() {
387 return mConceptSaturationPrecomputationChecked;
388 }
389
390
391 bool CTotallyOntologyPrecomputationItem::requiresAllConceptsSaturation() {
392 return mAllConSatRequired;
393 }
394
395 bool CTotallyOntologyPrecomputationItem::hasAllConceptsSaturationOrdered() {
396 return mAllConSatOrdered;
397 }
398
399 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllConceptsSaturationOrdered(bool ordered) {
400 mAllConSatOrdered = ordered;
401 return this;
402 }
403
404
405 bool CTotallyOntologyPrecomputationItem::requiresNominalDelayedConceptsSaturationUpdate() {
406 return mNomDelayedConSatUpRequired;
407 }
408
409 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setNominalDelayedConceptsSaturationUpdateRequired(bool updateRequired) {
410 mNomDelayedConSatUpRequired = updateRequired;
411 return this;
412 }
413
414
415
416 QList<CSaturationConceptDataItem*>* CTotallyOntologyPrecomputationItem::getSaturationOrderedItemList() {
417 return &mSatOrderedItemList;
418 }
419
420
421
422 bool CTotallyOntologyPrecomputationItem::hasRemainingRequiredSaturationConcepts() {
423 return !mRemainingReqSatConList.isEmpty() || mAllConSatRequired && !mAllConSatOrdered || mNomDelayedConSatUpRequired && !mNomDelayedConSatUpdated;
424 }
425
426 QList<TConceptNegPair>* CTotallyOntologyPrecomputationItem::getRemainingRequiredSaturationConceptList() {
427 return &mRemainingReqSatConList;
428 }
429
430 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addRequiredSaturationConcept(CConcept* concept, bool negation) {
431 if (!mAllConSatRequired) {
432 mRemainingReqSatConList.append(TConceptNegPair(concept,negation));
433 }
434 return this;
435 }
436
437
438
439
440 bool CTotallyOntologyPrecomputationItem::hasRemainingConsistencyRequiredSaturationConcepts() {
441 return !mRemainingConsReqSatConList.isEmpty();
442 }
443
444 QList<TConceptNegPair>* CTotallyOntologyPrecomputationItem::getRemainingConsistencyRequiredSaturationConceptList() {
445 return &mRemainingConsReqSatConList;
446 }
447
448 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addConsistencyRequiredSaturationConcept(CConcept* concept, bool negation) {
449 mRemainingConsReqSatConList.append(TConceptNegPair(concept,negation));
450 return this;
451 }
452
453
454
455
456 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setTripleIndexedIndividualSaturated(bool saturated) {
457 mTriplesIndexedIndisSaturated = saturated;
458 return this;
459 }
460
461
462
463 bool CTotallyOntologyPrecomputationItem::hasRemainingRequiredSaturationIndividuals() {
464 return !mRemainingABoxIndiSatList.isEmpty() || !mTriplesIndexedIndisSaturated || mRemainingABoxIndiSatLinker;
465 }
466
467
468 bool CTotallyOntologyPrecomputationItem::hasRemainingRequiredABoxSaturationIndividuals() {
469 return !mRemainingABoxIndiSatList.isEmpty() || mRemainingABoxIndiSatLinker;
470 }
471
472 QList<CIndividual*>* CTotallyOntologyPrecomputationItem::getRemainingRequiredABoxSaturationIndividuals() {
473 return &mRemainingABoxIndiSatList;
474 }
475
476 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addRequiredABoxSaturationIndividual(CIndividual* individual) {
477 mRemainingABoxIndiSatList.append(individual);
478 return this;
479 }
480
481 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setRequiredABoxSaturationIndividualLinker(CXLinker<CIndividual*>* individualLinker) {
482 mRemainingABoxIndiSatLinker = individualLinker;
483 return this;
484 }
485
486 bool CTotallyOntologyPrecomputationItem::hasRequiredABoxSaturationIndividualLinker() {
487 return mRemainingABoxIndiSatLinker;
488 }
489
490 cint64 CTotallyOntologyPrecomputationItem::getRemainingRequiredABoxSaturationIndividualCount() {
491 return mRemainingRequiredABoxSaturationIndividualCount;
492 }
493
494 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setRemainingRequiredABoxSaturationIndividualCount(cint64 count) {
495 mRemainingRequiredABoxSaturationIndividualCount = count;
496 return this;
497 }
498
499 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::decRemainingRequiredABoxSaturationIndividualCount(cint64 count) {
500 mRemainingRequiredABoxSaturationIndividualCount -= count;
501 return this;
502 }
503
504
505 CIndividual* CTotallyOntologyPrecomputationItem::getNextRequiredABoxSaturationIndividual(bool moveNext) {
506 CIndividual* indi = nullptr;
507 if (mRemainingABoxIndiSatLinker) {
508 indi = mRemainingABoxIndiSatLinker->getData();
509 if (moveNext) {
510 mRemainingABoxIndiSatLinker = mRemainingABoxIndiSatLinker->getNext();
511 }
512 }
513 return indi;
514 }
515
516
517
518 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addRequiredABoxSaturationIndividualLinkerArray(CXLinker<CIndividual*>* individualLinkerArray) {
519 mRemainingABoxIndiSatLinkerArrayList.append(individualLinkerArray);
520 return this;
521 }
522
523 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::clearRequiredABoxSaturationIndividualLinkerArrays() {
524 for (CXLinker<CIndividual*>* individualLinkerArray : mRemainingABoxIndiSatLinkerArrayList) {
525 delete[] individualLinkerArray;
526 }
527 mRemainingABoxIndiSatLinkerArrayList.clear();
528 return this;
529 }
530
531
532 cint64 CTotallyOntologyPrecomputationItem::getHandledTriplesIndividualSaturatedId() {
533 return mHandledTriplesIndiSaturatedId;
534 }
535
536
537 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setHandledTriplesIndividualSaturatedId(cint64 handledId) {
538 mHandledTriplesIndiSaturatedId = handledId;
539 return this;
540 }
541
542
543
544
545 QList<CConceptCycleData*>* CTotallyOntologyPrecomputationItem::getRemainingConceptCyclePrecomputationList() {
546 return &mRemainingConceptCyclePrecomputationList;
547 }
548
549 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addRemainingConceptCyclePrecomputation(CConceptCycleData* conceptCycleData) {
550 mRemainingConceptCyclePrecomputationList.append(conceptCycleData);
551 return this;
552 }
553
554 bool CTotallyOntologyPrecomputationItem::hasRemainingConceptCyclePrecomputation() {
555 return !mRemainingConceptCyclePrecomputationList.isEmpty();
556 }
557
558 cint64 CTotallyOntologyPrecomputationItem::getMinConceptCycleTestSize() {
559 return mMinConceptCycleTestSize;
560 }
561
562 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setMinConceptCycleTestSize(cint64 minSize) {
563 mMinConceptCycleTestSize = minSize;
564 return this;
565 }
566
567
568 CPrecomputationTestingStep* CTotallyOntologyPrecomputationItem::getConsistencePrecomputationStep() {
569 return mConsistencePrecomputationStep;
570 }
571
572 bool CTotallyOntologyPrecomputationItem::isConsistenceStepFinished() {
573 return mConsistencePrecomputationStep->isStepFinished();
574 }
575
576 bool CTotallyOntologyPrecomputationItem::isConsistenceStepRequired() {
577 return mConsistencePrecomputationStep->hasRequirements();
578 }
579
580 bool CTotallyOntologyPrecomputationItem::areConsistenceStepProcessingRequirementSatisfied() {
581 return mConsistencePrecomputationStep->areStepProcessingRequirementSatisfied();
582 }
583
584 bool CTotallyOntologyPrecomputationItem::areCycleStepProcessingRequirementSatisfied() {
585 return mCyclePrecomputationStep->areStepProcessingRequirementSatisfied();
586 }
587
588 CPrecomputationTestingStep* CTotallyOntologyPrecomputationItem::getCyclePrecomputationStep() {
589 return mCyclePrecomputationStep;
590 }
591
592 bool CTotallyOntologyPrecomputationItem::isCycleStepFinished() {
593 return mCyclePrecomputationStep->isStepFinished();
594 }
595
596 bool CTotallyOntologyPrecomputationItem::isCycleStepRequired() {
597 return mCyclePrecomputationStep->hasRequirements();
598 }
599
600
601
602 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setSaturationOccurrenceStatisticsCollectingInitialized(bool initialized) {
603 mSaturationOccurrenceStatisticsCollectingInitialized = initialized;
604 return this;
605 }
606
607 bool CTotallyOntologyPrecomputationItem::hasSaturationOccurrenceStatisticsCollectingInitialized() {
608 return mSaturationOccurrenceStatisticsCollectingInitialized;
609 }
610
611 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setSaturationOccurrenceStatisticsCollected(bool checked) {
612 mSaturationOccurrenceStatisticsCollected = checked;
613 return this;
614 }
615
616 bool CTotallyOntologyPrecomputationItem::hasSaturationOccurrenceStatisticsCollected() {
617 return mSaturationOccurrenceStatisticsCollected;
618 }
619
620
621 bool CTotallyOntologyPrecomputationItem::areOccurrenceStatisticsStepProcessingRequirementSatisfied() {
622 return mOccurrenceStatisticsPrecomputationStep->areStepProcessingRequirementSatisfied();
623 }
624
625 CPrecomputationTestingStep* CTotallyOntologyPrecomputationItem::getOccurrenceStatisticsPrecomputationStep() {
626 return mOccurrenceStatisticsPrecomputationStep;
627 }
628
629 bool CTotallyOntologyPrecomputationItem::isOccurrenceStatisticsStepFinished() {
630 return mOccurrenceStatisticsPrecomputationStep->isStepFinished();
631 }
632
633 bool CTotallyOntologyPrecomputationItem::isOccurrenceStatisticsStepRequired() {
634 return mOccurrenceStatisticsPrecomputationStep->hasRequirements();
635 }
636
637
638
639 bool CTotallyOntologyPrecomputationItem::areSaturationStepProcessingRequirementSatisfied() {
640 return mSaturationPrecomputationStep->areStepProcessingRequirementSatisfied();
641 }
642
643 CPrecomputationTestingStep* CTotallyOntologyPrecomputationItem::getSaturationPrecomputationStep() {
644 return mSaturationPrecomputationStep;
645 }
646
647 bool CTotallyOntologyPrecomputationItem::isSaturationStepRunning() {
648 return mSaturationTestRunning;
649 }
650
651 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setSaturationStepRunning(bool satStepRunning) {
652 mSaturationTestRunning = satStepRunning;
653 return this;
654 }
655
656
657 bool CTotallyOntologyPrecomputationItem::isSaturationComputationRunning() {
658 return mSaturationComputationRunning;
659 }
660
661 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setSaturationComputationRunning(bool satCompRunning) {
662 mSaturationComputationRunning = satCompRunning;
663 return this;
664 }
665
666 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::incIndividualSaturationRunningCount(cint64 incCount) {
667 mIndividualSaturationRunningCount += incCount;
668 return this;
669 }
670
671 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::decIndividualSaturationRunningCount(cint64 decCount) {
672 mIndividualSaturationRunningCount -= decCount;
673 return this;
674 }
675
676 cint64 CTotallyOntologyPrecomputationItem::getIndividualSaturationRunningCount() {
677 return mIndividualSaturationRunningCount;
678 }
679
680 bool CTotallyOntologyPrecomputationItem::hasIndividualSaturationRunning() {
681 return mIndividualSaturationRunningCount > 0;
682 }
683
684
685 bool CTotallyOntologyPrecomputationItem::isSaturationStepFinished() {
686 return mSaturationPrecomputationStep->isStepFinished();
687 }
688
689 bool CTotallyOntologyPrecomputationItem::isSaturationStepRequired() {
690 return mSaturationPrecomputationStep->hasRequirements();
691 }
692
693 bool CTotallyOntologyPrecomputationItem::areAllStepFinished() {
694 for (QList<CPrecomputationTestingStep*>::const_iterator it = mProcessingSteps.constBegin(), itEnd = mProcessingSteps.constEnd(); it != itEnd; ++it) {
695 if (!(*it)->isStepFinished()) {
696 return false;
697 }
698 }
699 return true;
700 }
701
702 bool CTotallyOntologyPrecomputationItem::hasRemainingProcessingRequirements() {
703 for (QList<CPrecomputationTestingStep*>::const_iterator it = mProcessingSteps.constBegin(), itEnd = mProcessingSteps.constEnd(); it != itEnd; ++it) {
704 if ((*it)->hasRequirements()) {
705 return true;
706 }
707 }
708 return false;
709 }
710
711
712
713 CSaturationConceptDataItem* CTotallyOntologyPrecomputationItem::getSaturationConceptDataItem(CConcept* satConcept, bool negated, bool create) {
714 CSaturationConceptDataItem* item = nullptr;
715 CConceptProcessData* conProcData = (CConceptProcessData*)satConcept->getConceptData();
716 CConceptReferenceLinking* conRefLinking = conProcData->getConceptReferenceLinking();
717 if (conRefLinking) {
718 CConceptSaturationReferenceLinkingData* conRefSatLinking = (CConceptSaturationReferenceLinkingData*)conRefLinking;
719 item = (CSaturationConceptDataItem*)conRefSatLinking->getConceptSaturationReferenceLinkingData(negated);
720 }
721 if (!item && create) {
722 item = new CSaturationConceptDataItem();
723 item->initConceptSaturationTestingItem(satConcept,negated,nullptr);
724 mConceptNegationSatItemHash.insert(TConceptNegPair(satConcept,negated),item);
725 mSatItemContainer.append(item);
726 }
727 return item;
728 }
729
730
731 CSaturationConceptDataItem* CTotallyOntologyPrecomputationItem::getSaturationRoleSuccessorConceptDataItem(CRole* role, CConcept* satConcept, bool negated, bool create) {
732 CSaturationConceptDataItem* item = nullptr;
733 item = mRoleConceptNegationSatItemHash.value(TRoleConceptNegTriple(role,TConceptNegPair(satConcept,negated)));
734 if (!item && create) {
735 item = new CSaturationConceptDataItem();
736 item->initConceptSaturationTestingItem(satConcept,negated,role);
737 mRoleConceptNegationSatItemHash.insert(TRoleConceptNegTriple(role,TConceptNegPair(satConcept,negated)),item);
738 mSatItemContainer.append(item);
739 }
740 return item;
741 }
742
743 CApproximatedSaturationCalculationJob* CTotallyOntologyPrecomputationItem::getSaturationCalculationJob() {
744 return mApproxSatCalcJob;
745 }
746
747 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setSaturationCalculationJob(CApproximatedSaturationCalculationJob* calculationJob) {
748 mApproxSatCalcJob = calculationJob;
749 return this;
750 }
751
752 QSet<CConcept*>* CTotallyOntologyPrecomputationItem::getSaturatedDisjunctionSet() {
753 return &mDisjunctionSaturationSet;
754 }
755
756 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addSaturatedDisjunction(CConcept* disjunctionConcept) {
757 mDisjunctionSaturationSet.insert(disjunctionConcept);
758 return this;
759 }
760
761
762 CIndividual* CTotallyOntologyPrecomputationItem::getAllAssertionIndividual() {
763 return mAllAssertionIndividual;
764 }
765
766 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllAssertionIndividual(CIndividual* individual) {
767 mAllAssertionIndividual = individual;
768 return this;
769 }
770
771
772 bool CTotallyOntologyPrecomputationItem::isAllAssertionIndividualSaturated() {
773 return mAllAssertionIndividualSaturated;
774 }
775
776 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllAssertionIndividualSaturated(bool saturated) {
777 mAllAssertionIndividualSaturated = saturated;
778 return this;
779 }
780
781
782 bool CTotallyOntologyPrecomputationItem::hasAllAssertionIndividualSufficientSaturationChecked() {
783 return mAllAssertionIndividualSufficientSaturationChecked;
784 }
785
786 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllAssertionIndividualSufficientSaturationChecked(bool sufficientSaturatedChecked) {
787 mAllAssertionIndividualSufficientSaturationChecked = sufficientSaturatedChecked;
788 return this;
789 }
790
791
792 bool CTotallyOntologyPrecomputationItem::isAllAssertionIndividualSaturationSufficient() {
793 return mAllAssertionIndividualSaturationSufficient;
794 }
795
796 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllAssertionIndividualSaturationSufficient(bool sufficientSaturated) {
797 mAllAssertionIndividualSaturationSufficient = sufficientSaturated;
798 return this;
799 }
800
801
802 CSaturationIndividualDataItem* CTotallyOntologyPrecomputationItem::takeFreeSaturationIndividualDataItem(bool create) {
803 CSaturationIndividualDataItem* item = mFreeItemLinker;
804 if (mFreeItemLinker) {
805 mFreeItemLinker = mFreeItemLinker->getNext();
806 }
807 if (item) {
808 item->clearNext();
809 }
810 if (!item) {
811 item = new CSaturationIndividualDataItem();
812 }
813 return item;
814 }
815
816 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::addFreeSaturationIndividualDataItem(CSaturationIndividualDataItem* item) {
817 if (item) {
818 for (CSaturationIndividualDataItem* itemIt = item; itemIt; itemIt = itemIt->getNext()) {
819 itemIt->initConceptSaturationTestingItem(nullptr,0);
820 }
821 mFreeItemLinker = item->append(mFreeItemLinker);
822 }
823 return this;
824 }
825
826 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setSaturationIDIndividualDataItems(cint64 saturationID, CSaturationIndividualDataItem* items) {
827 mSatIDIndividualItemsHash.insert(saturationID,items);
828 return this;
829 }
830
831 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::releaseSaturationIDIndividualDataItems(cint64 saturationID) {
832 CSaturationIndividualDataItem* items = mSatIDIndividualItemsHash.value(saturationID);
833 mSatIDIndividualItemsHash.insert(saturationID,nullptr);
834 addFreeSaturationIndividualDataItem(items);
835 return this;
836 }
837
838 cint64 CTotallyOntologyPrecomputationItem::getNextSaturationID(bool moveNext) {
839 cint64 nextID = mNextSaturationID;
840 if (moveNext) {
841 ++mNextSaturationID;
842 }
843 return nextID;
844 }
845
846
847
848 CSaturationIndividualAnalysationObserver* CTotallyOntologyPrecomputationItem::notifyClashedIndividual() {
849 mIndividualSaturationClashed = true;
850 return this;
851 }
852
853 CSaturationIndividualAnalysationObserver* CTotallyOntologyPrecomputationItem::notifyInsufficientIndividual() {
854 mIndividualSaturationInsufficient = true;
855 return this;
856 }
857
858
859 bool CTotallyOntologyPrecomputationItem::hasClashedSaturationIndividuals() {
860 return mIndividualSaturationClashed;
861 }
862
863 bool CTotallyOntologyPrecomputationItem::hasInsufficientSaturationIndividuals() {
864 return mIndividualSaturationInsufficient;
865 }
866
867
868
869 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setForceCompletionGraphConstruction(bool forceCompletionGraphConstruction) {
870 mForceCompletionGraphConstruction = forceCompletionGraphConstruction;
871 return this;
872 }
873
874 bool CTotallyOntologyPrecomputationItem::isForceCompletionGraphConstruction() {
875 return mForceCompletionGraphConstruction;
876 }
877
878
879 bool CTotallyOntologyPrecomputationItem::isFullCompletionGraphConstruction() {
880 return mFullCompletionGraphConstruction;
881 }
882
883 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setFullCompletionGraphConstruction(bool fullCompletionGraphConstruction) {
884 mFullCompletionGraphConstruction = fullCompletionGraphConstruction;
885 return this;
886 }
887
888 bool CTotallyOntologyPrecomputationItem::isFullCompletionGraphConstructed() {
889 return mFullCompletionGraphConstructed;
890 }
891
892 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setFullCompletionGraphConstructed(bool fullCompletionGraphConstructed) {
893 mFullCompletionGraphConstructed = fullCompletionGraphConstructed;
894 return this;
895 }
896
897
898
899
900 bool CTotallyOntologyPrecomputationItem::hasIndividualsSaturated() {
901 return mIndividualSaturated;
902 }
903
904 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualsSaturated(bool saturated) {
905 mIndividualSaturated = saturated;
906 return this;
907 }
908
909
910 bool CTotallyOntologyPrecomputationItem::hasALLIndividualsSaturationOrderd() {
911 return mAllIndividualSaturaturationOrderd;
912 }
913
914 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setALLIndividualsSaturationOrderd(bool allSaturationOrderd) {
915 mAllIndividualSaturaturationOrderd = allSaturationOrderd;
916 return this;
917 }
918
919
920 bool CTotallyOntologyPrecomputationItem::hasNominalDelayedConceptsSaturationUpdated() {
921 return mNomDelayedConSatUpdated;
922 }
923
924 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setNominalDelayedConceptsSaturationUpdated(bool updated) {
925 mNomDelayedConSatUpdated = updated;
926 return this;
927 }
928
929
930 bool CTotallyOntologyPrecomputationItem::hasIndividualsSaturationCacheSynchronisation() {
931 return mIndividualsSaturationCacheSynchronisation;
932 }
933
934 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualsSaturationCacheSynchronisation(bool synchronized) {
935 mIndividualsSaturationCacheSynchronisation = synchronized;
936 return this;
937 }
938
939
940
941 bool CTotallyOntologyPrecomputationItem::hasIndividualsSaturationAllOrderedCacheRetrieved() {
942 return mIndividualsSaturationAllOrderedCacheRetrieved;
943 }
944
945 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualsSaturationAllOrderedCacheRetrieved(bool retrieved) {
946 mIndividualsSaturationAllOrderedCacheRetrieved = retrieved;
947 return this;
948 }
949
950
951 QSet<CIndividualReference>* CTotallyOntologyPrecomputationItem::getIncompletelyHandledIndividualSet() {
952 return &mIncompHandledIndiSet;
953 }
954
955
956 CIndividualPrecomputationCoordinationHash* CTotallyOntologyPrecomputationItem::getCurrentIndividualComputationCoordinationHash() {
957 return mCurrentIndiCompCoordHash;
958 }
959
960 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setCurrentIndividualComputationCoordinationHash(CIndividualPrecomputationCoordinationHash* coordHash) {
961 mCurrentIndiCompCoordHash = coordHash;
962 return this;
963 }
964
965
966 QSet<CIndividualReference>* CTotallyOntologyPrecomputationItem::getCurrentIndividualComputationSet() {
967 return &mCurrentIndiComputationSet;
968 }
969
970 cint64 CTotallyOntologyPrecomputationItem::getCurrentIncompletelyHandledIndividualRetrievalLimit() {
971 return mCurrentIncompIndiRetrievalLimit;
972 }
973
974 double CTotallyOntologyPrecomputationItem::getCurrentIncompletelyHandledIndividualRetrievalThresholdFactor() {
975 return mCurrentIncompIndiRetrievalThresholdFactor;
976 }
977
978 cint64 CTotallyOntologyPrecomputationItem::getCurrentIncompletelyHandledIndividualRetrievalThreshold() {
979 return mCurrentIncompIndiRetrievalThreshold;
980 }
981
982 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setCurrentIncompletelyHandledIndividualRetrievalLimit(cint64 limit) {
983 mCurrentIncompIndiRetrievalLimit = limit;
984 return this;
985 }
986
987 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setCurrentIncompletelyHandledIndividualRetrievalThreshold(cint64 threshold) {
988 mCurrentIncompIndiRetrievalThreshold = threshold;
989 return this;
990 }
991
992 bool CTotallyOntologyPrecomputationItem::hasAllIncompletelyHandledIndividualsRetrieved() {
993 return mAllIncompIndiRetrieved;
994 }
995
996 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllIncompletelyHandledIndividualsRetrieved(bool allRetrieved) {
997 mAllIncompIndiRetrieved = allRetrieved;
998 return this;
999 }
1000
1001 bool CTotallyOntologyPrecomputationItem::hasFirstIncompletelyHandledIndividualsRetrieved() {
1002 return mFirstIncompletelyHandledIndividualsRetrieved;
1003 }
1004
1005 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setFirstIncompletelyHandledIndividualsRetrieved(bool retrieved) {
1006 mFirstIncompletelyHandledIndividualsRetrieved = retrieved;
1007 return this;
1008 }
1009
1010
1011 cint64 CTotallyOntologyPrecomputationItem::getLastMinimumRetrievedIncompletelyHandledIndividualId() {
1012 return mLastMinRetrievedIncompIndiId;
1013 }
1014
1015 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setLastMinimumRetrievedIncompletelyHandledIndividualId(cint64 minId) {
1016 mLastMinRetrievedIncompIndiId = minId;
1017 return this;
1018 }
1019
1020 bool CTotallyOntologyPrecomputationItem::areIndividualStepProcessingRequirementSatisfied() {
1021 return mIndividualPrecomputationStep->areStepProcessingRequirementSatisfied();
1022 }
1023
1024 CPrecomputationTestingStep* CTotallyOntologyPrecomputationItem::getIndividualPrecomputationStep() {
1025 return mIndividualPrecomputationStep;
1026 }
1027
1028 bool CTotallyOntologyPrecomputationItem::isIndividualStepRunning() {
1029 return mIndividualTestRunning;
1030 }
1031
1032 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualStepRunning(bool satStepRunning) {
1033 mIndividualTestRunning = satStepRunning;
1034 return this;
1035 }
1036
1037
1038 cint64 CTotallyOntologyPrecomputationItem::getIndividualComputationRunningCount() {
1039 return mIndividualComputationRunningCount;
1040 }
1041
1042 bool CTotallyOntologyPrecomputationItem::isIndividualComputationRunning() {
1043 return mIndividualComputationRunningCount > 0;
1044 }
1045
1046 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualComputationRunning(bool indiCompRunning) {
1047 mIndividualComputationRunning = indiCompRunning;
1048 return this;
1049 }
1050
1051
1052 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::incIndividualComputationRunningCount(cint64 incCount) {
1053 mIndividualComputationRunningCount += incCount;
1054 return this;
1055 }
1056
1057 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::decIndividualComputationRunningCount(cint64 decCount) {
1058 mIndividualComputationRunningCount -= decCount;
1059 return this;
1060 }
1061
1062
1063
1064 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setAllIndividualPrecomputationCreated(bool initialized) {
1065 mIndividualPrecomputationCreated = initialized;
1066 return this;
1067 }
1068
1069 bool CTotallyOntologyPrecomputationItem::hasAllIndividualPrecomputationCreated() {
1070 return mIndividualPrecomputationCreated;
1071 }
1072
1073
1074 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualPrecomputationChecked(bool checked) {
1075 mIndividualPrecomputationChecked = checked;
1076 return this;
1077 }
1078
1079
1080 bool CTotallyOntologyPrecomputationItem::hasIndividualPrecomputationChecked() {
1081 return mIndividualPrecomputationChecked;
1082 }
1083
1084
1085 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setIndividualPrecomputationClashed(bool checked) {
1086 mIndividualPrecomputationClashed = checked;
1087 return this;
1088 }
1089
1090
1091 bool CTotallyOntologyPrecomputationItem::hasIndividualPrecomputationClashed() {
1092 return mIndividualPrecomputationClashed;
1093 }
1094
1095 bool* CTotallyOntologyPrecomputationItem::getIndividualPrecomputationClashedPointer() {
1096 return &mIndividualPrecomputationClashed;
1097 }
1098
1099 bool* CTotallyOntologyPrecomputationItem::getIndividualPrecomputationExpansionLimitedReachedPointer() {
1100 return &mIndividualPrecomputationExpansionLimitedReachedPointer;
1101 }
1102
1103 bool CTotallyOntologyPrecomputationItem::isIndividualStepFinished() {
1104 return mIndividualPrecomputationStep->isStepFinished();
1105 }
1106
1107
1108 bool CTotallyOntologyPrecomputationItem::isIndividualStepRequired() {
1109 return mIndividualPrecomputationStep->hasRequirements();
1110 }
1111
1112
1113 QTime* CTotallyOntologyPrecomputationItem::getInitializationTime() {
1114 return &mInitTime;
1115 }
1116
1117
1118
1119 QTime*& CTotallyOntologyPrecomputationItem::getIndividualSaturationTime() {
1120 return mIndividualSaturationTime;
1121 }
1122
1123 QTime*& CTotallyOntologyPrecomputationItem::getIndividualPrecomputationTime() {
1124 return mIndividualPrecomputationTime;
1125 }
1126
1127 cint64 CTotallyOntologyPrecomputationItem::getCurrentIncompletelyHandledIndividualComputationLimit() {
1128 return mCurrentIncompIndiComputationLimit;
1129 }
1130
1131 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setCurrentIncompletelyHandledIndividualComputationLimit(cint64 limit) {
1132 mCurrentIncompIndiComputationLimit = limit;
1133 return this;
1134 }
1135
1136
1137
1138 double CTotallyOntologyPrecomputationItem::getMaximumRecomputationExpansionPropagationCuttedReductionFactor() {
1139 return mMaximumRecomputationExpansionPropagationCuttedReductionFactor;
1140 }
1141
1142 double CTotallyOntologyPrecomputationItem::getCurrentRecomputationExpansionPropagationCuttedReductionFactor() {
1143 return mCurrentRecomputationExpansionPropagationCuttedReductionFactor;
1144 }
1145
1146 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setCurrentRecomputationExpansionPropagationCuttedReductionFactor(double redFac) {
1147 mCurrentRecomputationExpansionPropagationCuttedReductionFactor = redFac;
1148 return this;
1149 }
1150
1151 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::incCurrentRecomputationExpansionPropagationCuttedReductionFactor(double redFac) {
1152 mCurrentRecomputationExpansionPropagationCuttedReductionFactor += redFac;
1153 if (mCurrentRecomputationExpansionPropagationCuttedReductionFactor > mMaximumRecomputationExpansionPropagationCuttedReductionFactor) {
1154 mCurrentRecomputationExpansionPropagationCuttedReductionFactor = mMaximumRecomputationExpansionPropagationCuttedReductionFactor;
1155 }
1156 return this;
1157 }
1158
1159 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::decCurrentRecomputationExpansionPropagationCuttedReductionFactor(double redFac) {
1160 mCurrentRecomputationExpansionPropagationCuttedReductionFactor -= redFac;
1161 if (mCurrentRecomputationExpansionPropagationCuttedReductionFactor < 0) {
1162 mCurrentRecomputationExpansionPropagationCuttedReductionFactor = 0;
1163 }
1164 return this;
1165 }
1166
1167
1168 double CTotallyOntologyPrecomputationItem::getRecomputationExpansionPropagationCuttedReductionIncreaseFactor() {
1169 return mRecomputationExpansionPropagationCuttedReductionIncreaseFactor;
1170 }
1171
1172 double CTotallyOntologyPrecomputationItem::getRecomputationExpansionPropagationCuttedReductionRecoveryFactor() {
1173 return mRecomputationExpansionPropagationCuttedReductionRecoveryFactor;
1174 }
1175
1176
1177
1178 cint64 CTotallyOntologyPrecomputationItem::getRecomputationExpansionPropagationCuttedCount() {
1179 return mIncompletelyHandledIndividualComputationPropagationCutReservedSize;
1180 }
1181
1182 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::incRecomputationExpansionPropagationCuttedCount(cint64 count) {
1183 mIncompletelyHandledIndividualComputationPropagationCutReservedSize += count;
1184 return this;
1185 }
1186
1187
1188 double CTotallyOntologyPrecomputationItem::getRemainingIncompletelyHandlingIndividualComputationLimitIncreasingCount() {
1189 return mRemainingIncompletelyHandlingIndividualComputationLimitIncreasingCount;
1190 }
1191
1192
1193 double CTotallyOntologyPrecomputationItem::getIncompletelyHandlingIndividualComputationLimitIncreasingFactor() {
1194 return mIncompletelyHandlingIndividualComputationLimitIncreasingFactor;
1195 }
1196
1197 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setRemainingIncompletelyHandlingIndividualComputationLimitIncreasingCount(cint64 indiCount) {
1198 mRemainingIncompletelyHandlingIndividualComputationLimitIncreasingCount = indiCount;
1199 return this;
1200 }
1201
1202
1203 cint64 CTotallyOntologyPrecomputationItem::getIndividualSaturationSizeLimit() {
1204 return mIndividualSaturationCount;
1205 }
1206
1207
1208 cint64 CTotallyOntologyPrecomputationItem::getNextRepresentativeCacheRecomputationId() {
1209 return mNextRepresentativeCacheRecomputationId++;
1210 }
1211
1212
1213
1214 bool CTotallyOntologyPrecomputationItem::isPrecompuationRetrievingIncompletelyHandledIndividuals() {
1215 return mPrecompuationRetrievingIncompletelyHandledIndividuals;
1216 }
1217
1218 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecompuationRetrievingIncompletelyHandledIndividuals(bool retrievingIndividuals) {
1219 mPrecompuationRetrievingIncompletelyHandledIndividuals = retrievingIndividuals;
1220 return this;
1221 }
1222
1223
1224 bool CTotallyOntologyPrecomputationItem::isPrecompuationIncompletelyHandledIndividualsRetrievalThresholdRequested() {
1225 return mPrecompuationIncompletelyHandledIndividualsRetrievalThresholdRequested;
1226 }
1227
1228 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecompuationIncompletelyHandledIndividualsRetrievalThresholdRequested(bool retrievingIndividuals) {
1229 mPrecompuationIncompletelyHandledIndividualsRetrievalThresholdRequested = retrievingIndividuals;
1230 return this;
1231 }
1232
1233 CIndividualPrecomputationCoordinationHash* CTotallyOntologyPrecomputationItem::getPrecomputationProcessingCoordinationHash() {
1234 return mPrecomputationProcessingCoordinationHash;
1235 }
1236
1237 CIndividualPrecomputationCoordinationHash* CTotallyOntologyPrecomputationItem::getPrecomputationRetrievalCoordinationHash() {
1238 return mPrecomputationRetrievalCoordinationHash;
1239 }
1240
1241 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecomputationProcessingCoordinationHash(CIndividualPrecomputationCoordinationHash* coordHash) {
1242 mPrecomputationProcessingCoordinationHash = coordHash;
1243 return this;
1244 }
1245
1246 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecomputationRetrievalCoordinationHash(CIndividualPrecomputationCoordinationHash* coordHash) {
1247 mPrecomputationRetrievalCoordinationHash = coordHash;
1248 return this;
1249 }
1250
1251
1252 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecomputationProcessingCoordinationHashIteratorCurrent(CBackendIndividualRetrievalComputationUpdateCoordinationHash::const_iterator coordHashIt) {
1253 mPrecomputationProcessingCoordinationHashIteratorCurrent = coordHashIt;
1254 return this;
1255 }
1256
1257 CBackendIndividualRetrievalComputationUpdateCoordinationHash::const_iterator CTotallyOntologyPrecomputationItem::getPrecomputationProcessingCoordinationHashIteratorCurrent() {
1258 return mPrecomputationProcessingCoordinationHashIteratorCurrent;
1259 }
1260
1261
1262
1263 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setPrecomputationProcessingCoordinationHashIteratorEnd(CBackendIndividualRetrievalComputationUpdateCoordinationHash::const_iterator coordHashIt) {
1264 mPrecomputationProcessingCoordinationHashIteratorEnd = coordHashIt;
1265 return this;
1266 }
1267
1268 CBackendIndividualRetrievalComputationUpdateCoordinationHash::const_iterator CTotallyOntologyPrecomputationItem::getPrecomputationProcessingCoordinationHashIteratorEnd() {
1269 return mPrecomputationProcessingCoordinationHashIteratorEnd;
1270 }
1271
1272
1273
1274 bool CTotallyOntologyPrecomputationItem::hadBasicPrecompuationMode() {
1275 return mHadBasicPrecompuationMode;
1276 }
1277
1278 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setBasicPrecompuationMode(bool basicMode) {
1279 mHadBasicPrecompuationMode = basicMode;
1280 return this;
1281 }
1282
1283 double CTotallyOntologyPrecomputationItem::getBasicPrecompuationSubsequentIndividualLimitReductionFactor() {
1284 return mBasicPrecompuationSubsequentIndividualLimitReductionFactor;
1285 }
1286
1287 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setBasicPrecompuationSubsequentIndividualLimitReductionFactor(double factor) {
1288 mBasicPrecompuationSubsequentIndividualLimitReductionFactor = factor;
1289 return this;
1290 }
1291
1292
1293
1294 double CTotallyOntologyPrecomputationItem::getBasicPrecompuationSubsequentIndividualLimitReductionInitializationFactor() {
1295 return mBasicPrecompuationSubsequentIndividualLimitReductionInitializationFactor;
1296 }
1297
1298 double CTotallyOntologyPrecomputationItem::getBasicPrecompuationSubsequentIndividualLimitReductionIncreasingFactor() {
1299 return mBasicPrecompuationSubsequentIndividualLimitReductionIncreasingFactor;
1300 }
1301
1302
1303 QMap<cint64, CIndividualPrecomputationTestingItem*>* CTotallyOntologyPrecomputationItem::getRecomputationIdTestingItemMap() {
1304 return &mRecomputationIdTestingItemMap;
1305 }
1306
1307 cint64 CTotallyOntologyPrecomputationItem::getMaxHandledRecomputationIdRemainingReporting() {
1308 return mMaxHandledRecomputationIdRemainingReporting;
1309 }
1310
1311 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setMaxHandledRecomputationIdRemainingReporting(cint64 remainingCount) {
1312 mMaxHandledRecomputationIdRemainingReporting = remainingCount;
1313 return this;
1314 }
1315
1316 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::decMaxHandledRecomputationIdRemainingReporting(cint64 count) {
1317 mMaxHandledRecomputationIdRemainingReporting -= count;
1318 return this;
1319 }
1320
1321
1322 double CTotallyOntologyPrecomputationItem::getBasicPrecompuationParallelizationReductionFactor() {
1323 return mBasicPrecompuationParallelizationReductionFactor;
1324 }
1325
1326 CTotallyOntologyPrecomputationItem* CTotallyOntologyPrecomputationItem::setBasicPrecompuationParallelizationReductionFactor(double factor) {
1327 mBasicPrecompuationParallelizationReductionFactor = factor;
1328 return this;
1329 }
1330
1331 double CTotallyOntologyPrecomputationItem::getBasicPrecompuationParallelizationInitializationFactor() {
1332 return mBasicPrecompuationParallelizationInitializationFactor;
1333 }
1334
1335 double CTotallyOntologyPrecomputationItem::getBasicPrecompuationParallelizationIncreasingFactor() {
1336 return mBasicPrecompuationParallelizationIncreasingFactor;
1337 }
1338
1339
1340
1341 }; // end namespace Consistiser
1342
1343 }; // end namespace Reasoner
1344
1345 }; // end namespace Konclude