/*
* 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 .
*
*/
#include "CTask.h"
namespace Konclude {
namespace Scheduler {
CTask::CTask(CMemoryPool* memoryPool) : CSortedLinkerBase(this,nullptr), CMemoryPoolContainer(memoryPool) {
}
CTask::~CTask() {
}
CTask* CTask::setTaskID(cint64 id) {
mTaskID = id;
return this;
}
cint64 CTask::getTaskID() const {
return mTaskID;
}
CTask* CTask::setTaskDepth(cint64 taskDepth) {
mTaskDepth = taskDepth;
return this;
}
cint64 CTask::getTaskDepth() const {
return mTaskDepth;
}
CTask* CTask::setTaskType(cint64 taskType) {
mTaskType = taskType;
return this;
}
cint64 CTask::getTaskType() const {
return mTaskType;
}
double CTask::getTaskPriority() const {
return mTaskPriority;
}
CTask* CTask::setTaskPriority(double taskPriority) {
mTaskPriority = taskPriority;
return this;
}
CTask* CTask::getParentTask() const {
return mParentTask;
}
CTask* CTask::getRootTask() const {
return mRootTask;
}
CTask* CTask::setParentTask(CTask* parentTask) {
mParentTask = parentTask;
return this;
}
CTask* CTask::setRootTask(CTask* rootTask) {
mRootTask = rootTask;
return this;
}
CTaskResult* CTask::getTaskResult() {
return mTaskResult;
}
CTaskStatus* CTask::getTaskStatus() {
return mTaskStatus;
}
CTaskContext* CTask::getTaskContext(CTaskHandleContext* context) {
if (!mTaskContext) {
void* memManAdd = CTaskMemoryPoolAllocationManager::allocateMemoryToContainer(sizeof(CTaskContextBase),this,context->getTaskHandleMemoryAllocationManager());
mTaskContext = new (memManAdd) CTaskContextBase(this,context);
} else {
mTaskContext->updateContext(context);
}
return mTaskContext;
}
CTask* CTask::decActiveReferenceCount(cint64 decCount) {
mActiveTaskReferenceCount -= decCount;
return this;
}
CTask* CTask::incActiveReferenceCount(cint64 incCount) {
mActiveTaskReferenceCount += incCount;
return this;
}
cint64 CTask::getActiveReferenceCount() const {
return mActiveTaskReferenceCount;
}
bool CTask::hasActiveReferencedTask() const {
return mActiveTaskReferenceCount > 0;
}
CTask* CTask::decDependedStatusUpdatesCount(cint64 decCount) {
mDependedStatusUpdatesCount -= decCount;
return this;
}
CTask* CTask::incDependedStatusUpdatesCount(cint64 incCount) {
mDependedStatusUpdatesCount += incCount;
return this;
}
cint64 CTask::getDependedStatusUpdatesCount() const {
return mDependedStatusUpdatesCount;
}
bool CTask::hasDependedStatusUpdates() const {
return mDependedStatusUpdatesCount > 0;
}
bool CTask::hasDependedStatusUpdatesOrActiveReferencedTasks() const {
return hasDependedStatusUpdates() || hasActiveReferencedTask();
}
CTask* CTask::makeTaskReference(CTask* dependedTask, CTaskHandleContext* handlerContext) {
dependedTask->setParentTask(this);
dependedTask->setRootTask(mRootTask);
dependedTask->setTaskDepth(mTaskDepth+1);
mActiveTaskReferenceCount++;
CTaskContext* taskContext = getTaskContext(handlerContext);
CXNegLinker* childNegLinker = CObjectAllocator >::allocateAndConstruct(taskContext->getMemoryAllocationManager());
mReferencedTaskLinker = childNegLinker->initNegLinker(dependedTask,true,mReferencedTaskLinker);
dependedTask->setCompletionNegatorConnector(childNegLinker);
return this;
}
CTask* CTask::initTask(CTask* parentTask, CTaskHandleContext* handlerContext) {
initLinker(this,nullptr);
mTaskStatus = nullptr;
mTaskResult = nullptr;
mRootTask = this;
mParentTask = nullptr;
mTaskContext = nullptr;
mCompletionNegator = nullptr;
mReferencedTaskLinker = nullptr;
mCallbackLinker = nullptr;
mTaskOwner = nullptr;
mTaskID = 0;
mTaskPriority = 0.;
mActiveTaskReferenceCount = 0;
mDependedStatusUpdatesCount = 0;
mTaskDepth = 0;
mCompletionRequested = false;
mTaskRelevant = false;
mTaskDispensMarked = false;
mTaskType = 0;
mTaskStatus = createTaskStatus(handlerContext);
mTaskResult = createTaskResult(handlerContext);
if (parentTask) {
parentTask->makeTaskReference(this,handlerContext);
mRootTask = parentTask->getRootTask();
}
return this;
}
CXNegLinker* CTask::getReferencedTaskLinker() {
return mReferencedTaskLinker;
}
CTask* CTask::setReferencedTaskLinker(CXNegLinker* referencedTaskLinker) {
mReferencedTaskLinker = referencedTaskLinker;
return this;
}
CTask* CTask::appendReferencedTaskLinker(CXNegLinker* referencedTaskLinker) {
mReferencedTaskLinker = referencedTaskLinker->getLastListLink()->setNext(mReferencedTaskLinker);
return this;
}
CTask* CTask::setCompletionNegatorConnector(CNegator* negator) {
mCompletionNegator = negator;
return this;
}
CTask* CTask::completeTask() {
if (mCompletionNegator) {
mCompletionNegator->setNegation(false);
}
return this;
}
CCallbackData* CTask::getCallbackLinker() {
return mCallbackLinker;
}
CTask* CTask::setCallbackLinker(CCallbackData* callback) {
mCallbackLinker = callback;
return this;
}
CTask* CTask::addCallbackLinker(CCallbackData* callback) {
mCallbackLinker = callback->getLastListLink()->setNext(mCallbackLinker);
return this;
}
CTaskOwner* CTask::getTaskOwner() {
return mTaskOwner;
}
CTask* CTask::setTaskOwner(CTaskOwner* taskOwner) {
mTaskOwner = taskOwner;
return this;
}
CTask* CTask::clearTaskOwner() {
mTaskOwner = nullptr;
return this;
}
bool CTask::hasTaskOwner(CTaskOwner* taskOwner) {
return mTaskOwner == taskOwner;
}
bool CTask::hasTaskOwner() {
return mTaskOwner;
}
bool CTask::hasNoTaskOwnerAndNoParentTask() {
return mTaskOwner == nullptr && mParentTask == nullptr;
}
CTask* CTask::setCompletionRequested(bool requested) {
mCompletionRequested = requested;
return this;
}
bool CTask::getCompletionRequested() {
return mCompletionRequested;
}
bool CTask::isCompletionRequested() {
return mCompletionRequested;
}
bool CTask::isTaskRelevant() {
return mTaskRelevant;
}
CTask* CTask::setTaskRelevant(bool relevant) {
mTaskRelevant = relevant;
return this;
}
bool CTask::isTaskDispenseMarked() {
return mTaskDispensMarked;
}
CTask* CTask::setTaskDispenseMarked(bool dispenseable) {
mTaskDispensMarked = dispenseable;
return this;
}
bool CTask::clearUninitializedReferenceTasks() {
bool clearedRefTasks = false;
CXNegLinker* refTaskIt = mReferencedTaskLinker;
while (refTaskIt) {
if (refTaskIt->isNegated() && refTaskIt->getData()->getTaskStatus()->isTaskStateUNINITIALIZED()) {
refTaskIt->setNegation(false);
--mActiveTaskReferenceCount;
clearedRefTasks = true;
}
refTaskIt = refTaskIt->getNext();
}
return clearedRefTasks;
}
}; // end namespace Scheduler
}; // end namespace Konclude