/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #ifndef KONCLUDE_SCHEDULER_CTASK_H #define KONCLUDE_SCHEDULER_CTASK_H // Libraries includes // Namespace includes #include "SchedulerSettings.h" #include "CTaskStatus.h" #include "CTaskResult.h" #include "CBooleanTaskResult.h" #include "CTaskHandleContext.h" #include "CTaskContext.h" #include "CTaskContextBase.h" #include "CTaskOwner.h" // Other includes #include "Utilities/Container/CLinker.h" #include "Utilities/Container/CSortedLinker.h" #include "Utilities/Container/CNegLinker.h" #include "Utilities/Memory/CMemoryPool.h" #include "Utilities/Memory/CMemoryPoolContainer.h" #include "Utilities/Memory/CDeletionContainer.h" #include "Utilities/Memory/CObjectAllocator.h" #include "Concurrent/Callback/CCallbackData.h" // Logger includes #include "Logger/CLogger.h" namespace Konclude { using namespace Utilities; using namespace Utilities::Container; using namespace Utilities::Memory; using namespace Concurrent::Callback; namespace Scheduler { /*! * * \class CTask * \author Andreas Steigmiller * \version 0.1 * \brief TODO * */ class CTask : public CSortedLinkerBase, public CMemoryPoolContainer, public CDeletionContainer { // public methods public: //! Constructor CTask(CMemoryPool* memoryPool = nullptr); //! Destructor virtual ~CTask(); CTask* setTaskID(cint64 id); cint64 getTaskID() const; CTask* setTaskDepth(cint64 taskDepth); cint64 getTaskDepth() const; CTask* setTaskType(cint64 taskType); cint64 getTaskType() const; double getTaskPriority() const; CTask* setTaskPriority(double taskPriority); CTask* getParentTask() const; CTask* getRootTask() const; CTask* setParentTask(CTask* parentTask); CTask* setRootTask(CTask* rootTask); CTaskResult* getTaskResult(); CTaskStatus* getTaskStatus(); virtual CTaskContext* getTaskContext(CTaskHandleContext* context); virtual CTask* makeTaskReference(CTask* dependedTask, CTaskHandleContext* handlerContext); virtual CTask* initTask(CTask* parentTask, CTaskHandleContext* context); virtual CTask* completeTask(); CTask* incActiveReferenceCount(cint64 incCount = 1); CTask* decActiveReferenceCount(cint64 decCount = 1); cint64 getActiveReferenceCount() const; bool hasActiveReferencedTask() const; CTask* incDependedStatusUpdatesCount(cint64 incCount = 1); CTask* decDependedStatusUpdatesCount(cint64 decCount = 1); cint64 getDependedStatusUpdatesCount() const; bool hasDependedStatusUpdates() const; bool hasDependedStatusUpdatesOrActiveReferencedTasks() const; CXNegLinker* getReferencedTaskLinker(); CTask* setReferencedTaskLinker(CXNegLinker* referencedTaskLinker); CTask* appendReferencedTaskLinker(CXNegLinker* referencedTaskLinker); CCallbackData* getCallbackLinker(); CTask* setCallbackLinker(CCallbackData* callback); CTask* addCallbackLinker(CCallbackData* callback); CTaskOwner* getTaskOwner(); CTask* setTaskOwner(CTaskOwner* taskOwner); CTask* clearTaskOwner(); bool hasTaskOwner(CTaskOwner* taskOwner); bool hasTaskOwner(); bool hasNoTaskOwnerAndNoParentTask(); bool clearUninitializedReferenceTasks(); static inline bool sortedLinkerDataCompare(CTask* const & beforeData1, CTask* const & data2) { return beforeData1->getTaskPriority() >= data2->getTaskPriority(); } CTask* setCompletionRequested(bool requested); bool getCompletionRequested(); bool isCompletionRequested(); bool isTaskRelevant(); CTask* setTaskRelevant(bool relevant); bool isTaskDispenseMarked(); CTask* setTaskDispenseMarked(bool dispenseable); // protected methods protected: CTask* setCompletionNegatorConnector(CNegator* negator); virtual CTaskStatus* createTaskStatus(CTaskHandleContext* handlerContext) = 0; virtual CTaskResult* createTaskResult(CTaskHandleContext* handlerContext) = 0; // protected variables protected: cint64 mTaskID; cint64 mTaskType; double mTaskPriority; bool mTaskRelevant; bool mTaskDispensMarked; CTaskStatus* mTaskStatus; CTaskResult* mTaskResult; CTaskContext* mTaskContext; CTaskOwner* mTaskOwner; CTask* mParentTask; CTask* mRootTask; cint64 mActiveTaskReferenceCount; cint64 mDependedStatusUpdatesCount; cint64 mTaskDepth; CXNegLinker* mReferencedTaskLinker; CNegator* mCompletionNegator; CCallbackData* mCallbackLinker; bool mCompletionRequested; // private methods private: // private variables private: }; }; // end namespace Scheduler }; // end namespace Konclude #endif // KONCLUDE_SCHEDULER_CTASK_H