Debian Codegraph @

Source/Reasoner/Kernel/Task/CSatisfiableCalculationTask.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 "CSatisfiableCalculationTask.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Kernel {
29
30 namespace Task {
31
32
33 CSatisfiableCalculationTask::CSatisfiableCalculationTask(CMemoryPool* memoryPool) : CTask(memoryPool) {
34 }
35
36 CSatisfiableCalculationTask::~CSatisfiableCalculationTask() {
37 }
38
39 CTaskResult* CSatisfiableCalculationTask::createTaskResult(CTaskHandleContext* handlerContext) {
40 return &mBoolTaskResult;
41 }
42
43 CTaskStatus* CSatisfiableCalculationTask::createTaskStatus(CTaskHandleContext* handlerContext) {
44 return &mDefaultTaskResult;
45 }
46
47
48 CTaskContext* CSatisfiableCalculationTask::getTaskContext(CTaskHandleContext* context) {
49 return getProcessContext(context);
50 }
51
52 CProcessContext* CSatisfiableCalculationTask::getProcessContext(CTaskHandleContext* context) {
53 if (!mProcessContext) {
54 void* memManAdd = CTaskMemoryPoolAllocationManager::allocateMemoryToContainer(sizeof(CProcessContextBase),this,context->getTaskHandleMemoryAllocationManager());
55 mProcessContext = new (memManAdd) CProcessContextBase(this,context);
56 mTaskContext = mProcessContext;
57 } else {
58 mProcessContext->updateContext(context);
59 }
60 return mProcessContext;
61 }
62
63 CProcessingDataBox* CSatisfiableCalculationTask::getProcessingDataBox() {
64 return mProcessingDataBox;
65 }
66
67
68 CTask* CSatisfiableCalculationTask::makeTaskReference(CTask* dependedTask, CTaskHandleContext* handlerContext) {
69 CTask::makeTaskReference(dependedTask,handlerContext);
70 CSatisfiableCalculationTask* depSatCalcTask = (CSatisfiableCalculationTask*)dependedTask;
71 depSatCalcTask->mProcessingDataBox->initProcessingDataBox(mProcessingDataBox);
72 depSatCalcTask->mProcessContext->referenceProcessContext(mProcessContext);
73 depSatCalcTask->mConsAdapter = mConsAdapter;
74 depSatCalcTask->mClassMessAdapter = mClassMessAdapter;
75 depSatCalcTask->mIndiAnalAdapter = mIndiAnalAdapter;
76 depSatCalcTask->mOccurrenceStatisticsCollectingAdapter = mOccurrenceStatisticsCollectingAdapter;
77 depSatCalcTask->mRealMessAdapter = mRealMessAdapter;
78 depSatCalcTask->mSatIncConsTestingAdapter = mSatIncConsTestingAdapter;
79 depSatCalcTask->mSatIndDepTrackAdapter = mSatIndDepTrackAdapter;
80 depSatCalcTask->mPossAssCollAdapter = mPossAssCollAdapter;
81 depSatCalcTask->mClassRoleMarkedMessageAdapter = mClassRoleMarkedMessageAdapter;
82 depSatCalcTask->mAnswererSubsumptionMessageAdapter = mAnswererSubsumptionMessageAdapter;
83 depSatCalcTask->mAnswererInstancePropagationMessageAdapter = mAnswererInstancePropagationMessageAdapter;
84 depSatCalcTask->mRepresentativeBackendUpdatingAdapter = mRepresentativeBackendUpdatingAdapter;
85 depSatCalcTask->mAnswererBindingPropagationAdapter = mAnswererBindingPropagationAdapter;
86 depSatCalcTask->mSatisfiablePossibleInstancesMergingAdapter = mSatisfiablePossibleInstancesMergingAdapter;
87 depSatCalcTask->mCancellationAdapter = mCancellationAdapter;
88 depSatCalcTask->mAnswererMaterializationAdapter = mAnswererMaterializationAdapter;
89 return this;
90 }
91
92 CTask* CSatisfiableCalculationTask::initTask(CTask* parentTask, CTaskHandleContext* context) {
93 mProcessContext = nullptr;
94 mProcessingDataBox = nullptr;
95 mConsAdapter = nullptr;
96 mIndiAnalAdapter = nullptr;
97 mOccurrenceStatisticsCollectingAdapter = nullptr;
98 mClassMessAdapter = nullptr;
99 mRealMessAdapter = nullptr;
100 mPossAssCollAdapter = nullptr;
101 mClassRoleMarkedMessageAdapter = nullptr;
102 mAnswererSubsumptionMessageAdapter = nullptr;
103 mAnswererInstancePropagationMessageAdapter = nullptr;
104 mRepresentativeBackendUpdatingAdapter = nullptr;
105 mAnswererBindingPropagationAdapter = nullptr;
106 mSatisfiablePossibleInstancesMergingAdapter = nullptr;
107 mCancellationAdapter = nullptr;
108 mAnswererMaterializationAdapter = nullptr;
109 mSatIncConsTestingAdapter = nullptr;
110 getProcessContext(context);
111 mProcessingDataBox = CObjectParameterizingAllocator< CProcessingDataBox,CProcessContext* >::allocateAndConstructAndParameterize(mProcessContext->getUsedMemoryAllocationManager(),mProcessContext);
112 CTask::initTask(parentTask,context);
113 return this;
114 }
115
116 CSatisfiableCalculationTask* CSatisfiableCalculationTask::initSatisfiableCalculationTask(CConcreteOntology* ontology, CCalculationConfigurationExtension* calculationConfig, CCalculationStatisticsCollector* calcStatCollector, CTaskHandleContext* context) {
117 initTask(nullptr,context);
118 mConsAdapter = nullptr;
119 mIndiAnalAdapter = nullptr;
120 mOccurrenceStatisticsCollectingAdapter = nullptr;
121 mClassMessAdapter = nullptr;
122 mRealMessAdapter = nullptr;
123 mPossAssCollAdapter = nullptr;
124 mClassRoleMarkedMessageAdapter = nullptr;
125 mAnswererSubsumptionMessageAdapter = nullptr;
126 mAnswererInstancePropagationMessageAdapter = nullptr;
127 mRepresentativeBackendUpdatingAdapter = nullptr;
128 mAnswererBindingPropagationAdapter = nullptr;
129 mSatisfiablePossibleInstancesMergingAdapter = nullptr;
130 mCancellationAdapter = nullptr;
131 mSatIncConsTestingAdapter = nullptr;
132 mAnswererMaterializationAdapter = nullptr;
133 mSatIndDepTrackAdapter = nullptr;
134 mCalcStatColl = calcStatCollector;
135 mCalculationConfig = calculationConfig;
136 mProcessingDataBox->initProcessingDataBox(ontology);
137 return this;
138 }
139
140
141 CSatisfiableCalculationTask* CSatisfiableCalculationTask::initUndependedSatisfiableCalculationTask(CSatisfiableCalculationTask* baseTask, CCalculationConfigurationExtension* calculationConfig, CCalculationStatisticsCollector* calcStatCollector, CTaskHandleContext* context) {
142 initTask(nullptr,context);
143 mConsAdapter = nullptr;
144 mIndiAnalAdapter = nullptr;
145 mOccurrenceStatisticsCollectingAdapter = nullptr;
146 mClassMessAdapter = nullptr;
147 mRealMessAdapter = nullptr;
148 mSatIncConsTestingAdapter = nullptr;
149 mSatIndDepTrackAdapter = nullptr;
150 mClassRoleMarkedMessageAdapter = nullptr;
151 mAnswererSubsumptionMessageAdapter = nullptr;
152 mAnswererBindingPropagationAdapter = nullptr;
153 mAnswererInstancePropagationMessageAdapter = nullptr;
154 mRepresentativeBackendUpdatingAdapter = nullptr;
155 mAnswererMaterializationAdapter = nullptr;
156 mSatisfiablePossibleInstancesMergingAdapter = nullptr;
157 mCancellationAdapter = nullptr;
158 mCalcStatColl = calcStatCollector;
159 mCalculationConfig = calculationConfig;
160 mProcessingDataBox->initProcessingDataBox(baseTask->mProcessingDataBox);
161 mProcessContext->referenceProcessContext(baseTask->mProcessContext);
162 mTaskType = baseTask->mTaskType;
163 return this;
164 }
165
166
167
168 CSatisfiableCalculationTask* CSatisfiableCalculationTask::initBranchDependedSatisfiableCalculationTask(CSatisfiableCalculationTask* dependedTask, CTaskHandleContext* context) {
169 initTask(dependedTask,context);
170 mCalcStatColl = dependedTask->mCalcStatColl;
171 mCalculationConfig = dependedTask->mCalculationConfig;
172 mTaskType = dependedTask->mTaskType;
173 return this;
174 }
175
176
177 CBooleanTaskResult* CSatisfiableCalculationTask::getSatisfiableCalculationTaskResult() {
178 return &mBoolTaskResult;
179 }
180
181 CCalculationConfigurationExtension* CSatisfiableCalculationTask::getCalculationConfiguration() {
182 return mCalculationConfig;
183 }
184
185 CTask* CSatisfiableCalculationTask::completeTask() {
186 #ifndef KONCLUDE_FORCE_STATISTIC_DEACTIVATED
187 if (mProcessContext && mProcessContext->getUsedProcessingStatisticsGathering()) {
188 if (mParentTask) {
189 // complete/flush statistics
190 CSatisfiableCalculationTask* parentSatTask = (CSatisfiableCalculationTask*)mParentTask;
191 if (parentSatTask->mProcessContext) {
192 mProcessContext->getUsedProcessingStatisticsGathering()->addGatheredProcessingStatisticsTo(parentSatTask->mProcessContext->getUsedProcessingStatisticsGathering());
193 }
194 } else if (mCalcStatColl) {
195 CProcessingStatisticGathering* gatheredProcStat = mProcessContext->getUsedProcessingStatisticsGathering();
196 CProcessingStatistics* processingStatistics = CProcessingStatistics::getProcessingStatistics();
197 QList<CProcessingStatisticDescription*>* statList = processingStatistics->getProcessingStatisticDescriptionList();
198 foreach (CProcessingStatisticDescription* statDesc, *statList) {
199 mCalcStatColl->addProcessingStatistics(statDesc->getStatisticDescriptionString(),gatheredProcStat->getGatheredProcessingStatistic(statDesc->getStatisticGatheringIndex()));
200 }
201 }
202 }
203 #endif
204 return CTask::completeTask();
205 }
206
207
208 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setConsistenceAdapter(CTaskPreyingAdapter* consistenceAdapter) {
209 mConsAdapter = consistenceAdapter;
210 return this;
211 }
212
213 CTaskPreyingAdapter* CSatisfiableCalculationTask::getConsistenceAdapter() {
214 return mConsAdapter;
215 }
216
217 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSaturationIndividualsAnalysationObserver(CSaturationIndividualsAnalysingAdapter* indiAnalAdapter) {
218 mIndiAnalAdapter = indiAnalAdapter;
219 return this;
220 }
221
222 CSaturationIndividualsAnalysingAdapter* CSatisfiableCalculationTask::getSaturationIndividualsAnalysationObserver() {
223 return mIndiAnalAdapter;
224 }
225
226
227
228 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setOccurrenceStatisticsCollectingAdapter(CSaturationOccurrenceStatisticsCollectingAdapter* collAdapter) {
229 mOccurrenceStatisticsCollectingAdapter = collAdapter;
230 return this;
231 }
232
233 CSaturationOccurrenceStatisticsCollectingAdapter* CSatisfiableCalculationTask::getOccurrenceStatisticsCollectingAdapter() {
234 return mOccurrenceStatisticsCollectingAdapter;
235 }
236
237
238 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setClassificationMessageAdapter(CSatisfiableTaskClassificationMessageAdapter* classMessAdapter) {
239 mClassMessAdapter = classMessAdapter;
240 return this;
241 }
242
243 CSatisfiableTaskClassificationMessageAdapter* CSatisfiableCalculationTask::getClassificationMessageAdapter() {
244 return mClassMessAdapter;
245 }
246
247
248 bool CSatisfiableCalculationTask::isCalculationTableauCompletionTask() {
249 return getTaskType() == CALCULATIONTABLEAUCOMPLETIONTASK;
250 }
251
252 bool CSatisfiableCalculationTask::isCalculationTableauSaturationTask() {
253 return getTaskType() == CALCULATIONTABLEAUAPPROXIMATEDSATURATIONTASK;
254 }
255
256 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setCalculationTaskType(cint64 taskType) {
257 mTaskType = taskType;
258 return this;
259 }
260
261 cint64 CSatisfiableCalculationTask::getCalculationTaskType() {
262 return getTaskType();
263 }
264
265 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setRealizationMarkedCandidatesMessageAdapter(CSatisfiableTaskRealizationMarkedCandidatesMessageAdapter* realMessObserver) {
266 mRealMessAdapter = realMessObserver;
267 return this;
268 }
269
270 CSatisfiableTaskRealizationMarkedCandidatesMessageAdapter* CSatisfiableCalculationTask::getRealizationMarkedCandidatesMessageAdapter() {
271 return mRealMessAdapter;
272 }
273
274
275 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableTaskIncrementalConsistencyTestingAdapter(CSatisfiableTaskIncrementalConsistencyTestingAdapter* incConsTestAdaptor) {
276 mSatIncConsTestingAdapter = incConsTestAdaptor;
277 return this;
278 }
279
280 CSatisfiableTaskIncrementalConsistencyTestingAdapter* CSatisfiableCalculationTask::getSatisfiableTaskIncrementalConsistencyTestingAdapter() {
281 return mSatIncConsTestingAdapter;
282 }
283
284 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableTaskIndividualDependenceTrackingAdapter(CSatisfiableTaskIndividualDependenceTrackingAdapter* indDepTrackAdaptor) {
285 mSatIndDepTrackAdapter = indDepTrackAdaptor;
286 return this;
287 }
288
289 CSatisfiableTaskIndividualDependenceTrackingAdapter* CSatisfiableCalculationTask::getSatisfiableTaskIndividualDependenceTrackingAdapter() {
290 return mSatIndDepTrackAdapter;
291 }
292
293 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setPossibleAssertionCollectionAdapter(CSatisfiableTaskRealizationPossibleAssertionCollectingAdapter* possAssCollAdapter) {
294 mPossAssCollAdapter = possAssCollAdapter;
295 return this;
296 }
297
298 CSatisfiableTaskRealizationPossibleAssertionCollectingAdapter* CSatisfiableCalculationTask::getPossibleAssertionCollectionAdapter() {
299 return mPossAssCollAdapter;
300 }
301
302 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableClassificationRoleMarkedMessageAdapter(CSatisfiableTaskClassificationRoleMarkedMessageAdapter* classRoleMarkedMessageAdapter) {
303 mClassRoleMarkedMessageAdapter = classRoleMarkedMessageAdapter;
304 return this;
305 }
306
307 CSatisfiableTaskClassificationRoleMarkedMessageAdapter* CSatisfiableCalculationTask::getSatisfiableClassificationRoleMarkedMessageAdapter() {
308 return mClassRoleMarkedMessageAdapter;
309 }
310
311 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableAnswererSubsumptionMessageAdapter(CSatisfiableTaskAnswererSubsumptionMessageAdapter* answererMessageAdapter) {
312 mAnswererSubsumptionMessageAdapter = answererMessageAdapter;
313 return this;
314 }
315
316 CSatisfiableTaskAnswererSubsumptionMessageAdapter* CSatisfiableCalculationTask::getSatisfiableAnswererSubsumptionMessageAdapter() {
317 return mAnswererSubsumptionMessageAdapter;
318 }
319
320 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableAnswererBindingPropagationAdapter(CSatisfiableTaskAnswererBindingPropagationAdapter* answererMessageAdapter) {
321 mAnswererBindingPropagationAdapter = answererMessageAdapter;
322 return this;
323 }
324
325 CSatisfiableTaskAnswererBindingPropagationAdapter* CSatisfiableCalculationTask::getSatisfiableAnswererBindingPropagationAdapter() {
326 return mAnswererBindingPropagationAdapter;
327 }
328
329 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiablePossibleInstancesMergingAdapter(CSatisfiableTaskRealizationPossibleInstancesMergingAdapter* possInstMergingAdapter) {
330 mSatisfiablePossibleInstancesMergingAdapter = possInstMergingAdapter;
331 return this;
332 }
333
334 CSatisfiableTaskRealizationPossibleInstancesMergingAdapter* CSatisfiableCalculationTask::getSatisfiablePossibleInstancesMergingAdapter() {
335 return mSatisfiablePossibleInstancesMergingAdapter;
336 }
337
338
339 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableAnswererInstancePropagationMessageAdapter(CSatisfiableTaskAnswererInstancePropagationMessageAdapter* answererMessageAdapter) {
340 mAnswererInstancePropagationMessageAdapter = answererMessageAdapter;
341 return this;
342 }
343
344 CSatisfiableTaskAnswererInstancePropagationMessageAdapter* CSatisfiableCalculationTask::getSatisfiableAnswererInstancePropagationMessageAdapter() {
345 return mAnswererInstancePropagationMessageAdapter;
346 }
347
348
349 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableRepresentativeBackendCacheUpdatingAdapter(CSatisfiableTaskRepresentativeBackendUpdatingAdapter* representativeBackendUpdatingAdapter) {
350 mRepresentativeBackendUpdatingAdapter = representativeBackendUpdatingAdapter;
351 return this;
352 }
353
354 CSatisfiableTaskRepresentativeBackendUpdatingAdapter* CSatisfiableCalculationTask::getSatisfiableRepresentativeBackendCacheUpdatingAdapter() {
355 return mRepresentativeBackendUpdatingAdapter;
356 }
357
358
359
360
361 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setSatisfiableAnswererMaterializationAdapter(CSatisfiableTaskAnswererQueryingMaterializationAdapter* representativeBackendUpdatingAdapter) {
362 mAnswererMaterializationAdapter = representativeBackendUpdatingAdapter;
363 return this;
364 }
365
366 CSatisfiableTaskAnswererQueryingMaterializationAdapter* CSatisfiableCalculationTask::getSatisfiableAnswererMaterializationAdapter() {
367 return mAnswererMaterializationAdapter;
368 }
369
370
371
372 CSatisfiableCalculationTask* CSatisfiableCalculationTask::setCancellationAdapter(CSatisfiableTaskCancellationAdapter* cancelAdapter) {
373 mCancellationAdapter = cancelAdapter;
374 return this;
375 }
376
377 CSatisfiableTaskCancellationAdapter* CSatisfiableCalculationTask::getCancellationAdapter() {
378 return mCancellationAdapter;
379 }
380
381
382
383 }; // end namespace Task
384
385 }; // end namespace Kernel
386
387 }; // end namespace Reasoner
388
389 }; // end namespace Konclude