Debian Codegraph @

Source/Scheduler/CTask.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 "CTask.h"
22
23
24 namespace Konclude {
25
26 namespace Scheduler {
27
28
29
30 CTask::CTask(CMemoryPool* memoryPool) : CSortedLinkerBase<CTask*,CTask,CTask>(this,nullptr), CMemoryPoolContainer(memoryPool) {
31 }
32
33 CTask::~CTask() {
34 }
35
36 CTask* CTask::setTaskID(cint64 id) {
37 mTaskID = id;
38 return this;
39 }
40
41 cint64 CTask::getTaskID() const {
42 return mTaskID;
43 }
44
45 CTask* CTask::setTaskDepth(cint64 taskDepth) {
46 mTaskDepth = taskDepth;
47 return this;
48 }
49
50 cint64 CTask::getTaskDepth() const {
51 return mTaskDepth;
52 }
53
54
55 CTask* CTask::setTaskType(cint64 taskType) {
56 mTaskType = taskType;
57 return this;
58 }
59
60 cint64 CTask::getTaskType() const {
61 return mTaskType;
62 }
63
64
65 double CTask::getTaskPriority() const {
66 return mTaskPriority;
67 }
68
69 CTask* CTask::setTaskPriority(double taskPriority) {
70 mTaskPriority = taskPriority;
71 return this;
72 }
73
74 CTask* CTask::getParentTask() const {
75 return mParentTask;
76 }
77
78 CTask* CTask::getRootTask() const {
79 return mRootTask;
80 }
81
82
83 CTask* CTask::setParentTask(CTask* parentTask) {
84 mParentTask = parentTask;
85 return this;
86 }
87
88 CTask* CTask::setRootTask(CTask* rootTask) {
89 mRootTask = rootTask;
90 return this;
91 }
92
93
94 CTaskResult* CTask::getTaskResult() {
95 return mTaskResult;
96 }
97
98 CTaskStatus* CTask::getTaskStatus() {
99 return mTaskStatus;
100 }
101
102
103 CTaskContext* CTask::getTaskContext(CTaskHandleContext* context) {
104 if (!mTaskContext) {
105 void* memManAdd = CTaskMemoryPoolAllocationManager::allocateMemoryToContainer(sizeof(CTaskContextBase),this,context->getTaskHandleMemoryAllocationManager());
106 mTaskContext = new (memManAdd) CTaskContextBase(this,context);
107 } else {
108 mTaskContext->updateContext(context);
109 }
110 return mTaskContext;
111 }
112
113
114 CTask* CTask::decActiveReferenceCount(cint64 decCount) {
115 mActiveTaskReferenceCount -= decCount;
116 return this;
117 }
118
119 CTask* CTask::incActiveReferenceCount(cint64 incCount) {
120 mActiveTaskReferenceCount += incCount;
121 return this;
122 }
123
124 cint64 CTask::getActiveReferenceCount() const {
125 return mActiveTaskReferenceCount;
126 }
127
128 bool CTask::hasActiveReferencedTask() const {
129 return mActiveTaskReferenceCount > 0;
130 }
131
132
133 CTask* CTask::decDependedStatusUpdatesCount(cint64 decCount) {
134 mDependedStatusUpdatesCount -= decCount;
135 return this;
136 }
137
138 CTask* CTask::incDependedStatusUpdatesCount(cint64 incCount) {
139 mDependedStatusUpdatesCount += incCount;
140 return this;
141 }
142
143 cint64 CTask::getDependedStatusUpdatesCount() const {
144 return mDependedStatusUpdatesCount;
145 }
146
147 bool CTask::hasDependedStatusUpdates() const {
148 return mDependedStatusUpdatesCount > 0;
149 }
150
151 bool CTask::hasDependedStatusUpdatesOrActiveReferencedTasks() const {
152 return hasDependedStatusUpdates() || hasActiveReferencedTask();
153 }
154
155
156 CTask* CTask::makeTaskReference(CTask* dependedTask, CTaskHandleContext* handlerContext) {
157 dependedTask->setParentTask(this);
158 dependedTask->setRootTask(mRootTask);
159 dependedTask->setTaskDepth(mTaskDepth+1);
160 mActiveTaskReferenceCount++;
161 CTaskContext* taskContext = getTaskContext(handlerContext);
162 CXNegLinker<CTask*>* childNegLinker = CObjectAllocator<CXNegLinker<CTask*> >::allocateAndConstruct(taskContext->getMemoryAllocationManager());
163 mReferencedTaskLinker = childNegLinker->initNegLinker(dependedTask,true,mReferencedTaskLinker);
164 dependedTask->setCompletionNegatorConnector(childNegLinker);
165 return this;
166 }
167
168
169 CTask* CTask::initTask(CTask* parentTask, CTaskHandleContext* handlerContext) {
170 initLinker(this,nullptr);
171 mTaskStatus = nullptr;
172 mTaskResult = nullptr;
173 mRootTask = this;
174 mParentTask = nullptr;
175 mTaskContext = nullptr;
176 mCompletionNegator = nullptr;
177 mReferencedTaskLinker = nullptr;
178 mCallbackLinker = nullptr;
179 mTaskOwner = nullptr;
180 mTaskID = 0;
181 mTaskPriority = 0.;
182 mActiveTaskReferenceCount = 0;
183 mDependedStatusUpdatesCount = 0;
184 mTaskDepth = 0;
185 mCompletionRequested = false;
186 mTaskRelevant = false;
187 mTaskDispensMarked = false;
188 mTaskType = 0;
189
190 mTaskStatus = createTaskStatus(handlerContext);
191 mTaskResult = createTaskResult(handlerContext);
192
193 if (parentTask) {
194 parentTask->makeTaskReference(this,handlerContext);
195 mRootTask = parentTask->getRootTask();
196 }
197 return this;
198 }
199
200
201 CXNegLinker<CTask*>* CTask::getReferencedTaskLinker() {
202 return mReferencedTaskLinker;
203 }
204
205 CTask* CTask::setReferencedTaskLinker(CXNegLinker<CTask*>* referencedTaskLinker) {
206 mReferencedTaskLinker = referencedTaskLinker;
207 return this;
208 }
209
210 CTask* CTask::appendReferencedTaskLinker(CXNegLinker<CTask*>* referencedTaskLinker) {
211 mReferencedTaskLinker = referencedTaskLinker->getLastListLink()->setNext(mReferencedTaskLinker);
212 return this;
213 }
214
215
216 CTask* CTask::setCompletionNegatorConnector(CNegator* negator) {
217 mCompletionNegator = negator;
218 return this;
219 }
220
221 CTask* CTask::completeTask() {
222 if (mCompletionNegator) {
223 mCompletionNegator->setNegation(false);
224 }
225 return this;
226 }
227
228
229 CCallbackData* CTask::getCallbackLinker() {
230 return mCallbackLinker;
231 }
232
233 CTask* CTask::setCallbackLinker(CCallbackData* callback) {
234 mCallbackLinker = callback;
235 return this;
236 }
237
238 CTask* CTask::addCallbackLinker(CCallbackData* callback) {
239 mCallbackLinker = callback->getLastListLink()->setNext(mCallbackLinker);
240 return this;
241 }
242
243
244 CTaskOwner* CTask::getTaskOwner() {
245 return mTaskOwner;
246 }
247
248 CTask* CTask::setTaskOwner(CTaskOwner* taskOwner) {
249 mTaskOwner = taskOwner;
250 return this;
251 }
252
253 CTask* CTask::clearTaskOwner() {
254 mTaskOwner = nullptr;
255 return this;
256 }
257
258 bool CTask::hasTaskOwner(CTaskOwner* taskOwner) {
259 return mTaskOwner == taskOwner;
260 }
261
262 bool CTask::hasTaskOwner() {
263 return mTaskOwner;
264 }
265
266 bool CTask::hasNoTaskOwnerAndNoParentTask() {
267 return mTaskOwner == nullptr && mParentTask == nullptr;
268 }
269
270
271 CTask* CTask::setCompletionRequested(bool requested) {
272 mCompletionRequested = requested;
273 return this;
274 }
275
276 bool CTask::getCompletionRequested() {
277 return mCompletionRequested;
278 }
279
280 bool CTask::isCompletionRequested() {
281 return mCompletionRequested;
282 }
283
284
285 bool CTask::isTaskRelevant() {
286 return mTaskRelevant;
287 }
288
289 CTask* CTask::setTaskRelevant(bool relevant) {
290 mTaskRelevant = relevant;
291 return this;
292 }
293
294
295 bool CTask::isTaskDispenseMarked() {
296 return mTaskDispensMarked;
297 }
298
299 CTask* CTask::setTaskDispenseMarked(bool dispenseable) {
300 mTaskDispensMarked = dispenseable;
301 return this;
302 }
303
304 bool CTask::clearUninitializedReferenceTasks() {
305 bool clearedRefTasks = false;
306 CXNegLinker<CTask*>* refTaskIt = mReferencedTaskLinker;
307 while (refTaskIt) {
308 if (refTaskIt->isNegated() && refTaskIt->getData()->getTaskStatus()->isTaskStateUNINITIALIZED()) {
309 refTaskIt->setNegation(false);
310 --mActiveTaskReferenceCount;
311 clearedRefTasks = true;
312 }
313 refTaskIt = refTaskIt->getNext();
314 }
315 return clearedRefTasks;
316 }
317
318
319 }; // end namespace Scheduler
320
321 }; // end namespace Konclude