Debian Codegraph @

Source/Scheduler/CTask.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_SCHEDULER_CTASK_H
22 #define KONCLUDE_SCHEDULER_CTASK_H
23
24 // Libraries includes
25
26
27 // Namespace includes
28 #include "SchedulerSettings.h"
29 #include "CTaskStatus.h"
30 #include "CTaskResult.h"
31 #include "CBooleanTaskResult.h"
32 #include "CTaskHandleContext.h"
33 #include "CTaskContext.h"
34 #include "CTaskContextBase.h"
35 #include "CTaskOwner.h"
36
37
38 // Other includes
39 #include "Utilities/Container/CLinker.h"
40 #include "Utilities/Container/CSortedLinker.h"
41 #include "Utilities/Container/CNegLinker.h"
42 #include "Utilities/Memory/CMemoryPool.h"
43 #include "Utilities/Memory/CMemoryPoolContainer.h"
44 #include "Utilities/Memory/CDeletionContainer.h"
45 #include "Utilities/Memory/CObjectAllocator.h"
46
47
48 #include "Concurrent/Callback/CCallbackData.h"
49
50
51 // Logger includes
52 #include "Logger/CLogger.h"
53
54
55
56 namespace Konclude {
57
58 using namespace Utilities;
59 using namespace Utilities::Container;
60 using namespace Utilities::Memory;
61 using namespace Concurrent::Callback;
62
63 namespace Scheduler {
64
65
66 /*!
67 *
68 * \class CTask
69 * \author Andreas Steigmiller
70 * \version 0.1
71 * \brief TODO
72 *
73 */
74 class CTask : public CSortedLinkerBase<CTask*,CTask,CTask>, public CMemoryPoolContainer, public CDeletionContainer {
75 // public methods
76 public:
77 //! Constructor
78 CTask(CMemoryPool* memoryPool = nullptr);
79
80 //! Destructor
81 virtual ~CTask();
82
83 CTask* setTaskID(cint64 id);
84 cint64 getTaskID() const;
85
86 CTask* setTaskDepth(cint64 taskDepth);
87 cint64 getTaskDepth() const;
88
89 CTask* setTaskType(cint64 taskType);
90 cint64 getTaskType() const;
91
92 double getTaskPriority() const;
93 CTask* setTaskPriority(double taskPriority);
94
95 CTask* getParentTask() const;
96 CTask* getRootTask() const;
97
98 CTask* setParentTask(CTask* parentTask);
99 CTask* setRootTask(CTask* rootTask);
100
101 CTaskResult* getTaskResult();
102 CTaskStatus* getTaskStatus();
103
104 virtual CTaskContext* getTaskContext(CTaskHandleContext* context);
105
106 virtual CTask* makeTaskReference(CTask* dependedTask, CTaskHandleContext* handlerContext);
107
108 virtual CTask* initTask(CTask* parentTask, CTaskHandleContext* context);
109
110 virtual CTask* completeTask();
111
112 CTask* incActiveReferenceCount(cint64 incCount = 1);
113 CTask* decActiveReferenceCount(cint64 decCount = 1);
114 cint64 getActiveReferenceCount() const;
115 bool hasActiveReferencedTask() const;
116
117 CTask* incDependedStatusUpdatesCount(cint64 incCount = 1);
118 CTask* decDependedStatusUpdatesCount(cint64 decCount = 1);
119 cint64 getDependedStatusUpdatesCount() const;
120 bool hasDependedStatusUpdates() const;
121
122 bool hasDependedStatusUpdatesOrActiveReferencedTasks() const;
123
124 CXNegLinker<CTask*>* getReferencedTaskLinker();
125 CTask* setReferencedTaskLinker(CXNegLinker<CTask*>* referencedTaskLinker);
126 CTask* appendReferencedTaskLinker(CXNegLinker<CTask*>* referencedTaskLinker);
127
128 CCallbackData* getCallbackLinker();
129 CTask* setCallbackLinker(CCallbackData* callback);
130 CTask* addCallbackLinker(CCallbackData* callback);
131
132
133 CTaskOwner* getTaskOwner();
134 CTask* setTaskOwner(CTaskOwner* taskOwner);
135 CTask* clearTaskOwner();
136 bool hasTaskOwner(CTaskOwner* taskOwner);
137 bool hasTaskOwner();
138
139 bool hasNoTaskOwnerAndNoParentTask();
140
141
142 bool clearUninitializedReferenceTasks();
143
144
145 static inline bool sortedLinkerDataCompare(CTask* const & beforeData1, CTask* const & data2) {
146 return beforeData1->getTaskPriority() >= data2->getTaskPriority();
147 }
148
149 CTask* setCompletionRequested(bool requested);
150 bool getCompletionRequested();
151 bool isCompletionRequested();
152
153 bool isTaskRelevant();
154 CTask* setTaskRelevant(bool relevant);
155
156 bool isTaskDispenseMarked();
157 CTask* setTaskDispenseMarked(bool dispenseable);
158
159
160 // protected methods
161 protected:
162 CTask* setCompletionNegatorConnector(CNegator* negator);
163
164 virtual CTaskStatus* createTaskStatus(CTaskHandleContext* handlerContext) = 0;
165 virtual CTaskResult* createTaskResult(CTaskHandleContext* handlerContext) = 0;
166
167 // protected variables
168 protected:
169 cint64 mTaskID;
170 cint64 mTaskType;
171 double mTaskPriority;
172 bool mTaskRelevant;
173 bool mTaskDispensMarked;
174 CTaskStatus* mTaskStatus;
175 CTaskResult* mTaskResult;
176
177 CTaskContext* mTaskContext;
178 CTaskOwner* mTaskOwner;
179
180 CTask* mParentTask;
181 CTask* mRootTask;
182 cint64 mActiveTaskReferenceCount;
183 cint64 mDependedStatusUpdatesCount;
184 cint64 mTaskDepth;
185
186 CXNegLinker<CTask*>* mReferencedTaskLinker;
187 CNegator* mCompletionNegator;
188 CCallbackData* mCallbackLinker;
189
190 bool mCompletionRequested;
191
192
193 // private methods
194 private:
195
196 // private variables
197 private:
198
199 };
200
201 }; // end namespace Scheduler
202
203 }; // end namespace Konclude
204
205 #endif // KONCLUDE_SCHEDULER_CTASK_H