feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

TaskTree: Do internal renaming

Browse Source 
Change-Id: I2c32156f553bc692d09c4f1b6f6e7bf5a4332f99
Reviewed-by: hjk <hjk@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
This commit is contained in:
Jarek Kobus
2024-01-03 18:48:08 +01:00
parent 79cde2741b
commit 91e2437112
2 changed files with 93 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

182
src/libs/solutions/tasking/tasktree.cpp
View File

@@ -1345,30 +1345,30 @@ GroupItem GroupItem::withTimeout(const GroupItem &item, milliseconds timeout,
class TaskTreePrivate; class TaskTreePrivate;
class TaskNode; class TaskNode;
class TaskRuntimeNode; class RuntimeTask;
class TaskRuntimeContainer; class RuntimeContainer;
class ExecutionContextActivator class ExecutionContextActivator
{ {
public: public:
ExecutionContextActivator(TaskRuntimeContainer *container) { activateContext(container); } ExecutionContextActivator(RuntimeContainer *container) { activateContext(container); }
~ExecutionContextActivator() { ~ExecutionContextActivator() {
for (int i = m_activeStorages.size() - 1; i >= 0; --i) // iterate in reverse order for (int i = m_activeStorages.size() - 1; i >= 0; --i) // iterate in reverse order
m_activeStorages[i].m_storageData->threadData().popStorage(); m_activeStorages[i].m_storageData->threadData().popStorage();
} }
private: private:
void activateContext(TaskRuntimeContainer *container); void activateContext(RuntimeContainer *container);
QList<StorageBase> m_activeStorages; QList<StorageBase> m_activeStorages;
}; };
class TaskContainer class ContainerNode
{ {
Q_DISABLE_COPY(TaskContainer) Q_DISABLE_COPY(ContainerNode)
public: public:
TaskContainer(TaskContainer &&other) = default; ContainerNode(ContainerNode &&other) = default;
TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task); ContainerNode(TaskTreePrivate *taskTreePrivate, const GroupItem &task);
TaskTreePrivate *const m_taskTreePrivate = nullptr; TaskTreePrivate *const m_taskTreePrivate = nullptr;
@@ -1395,7 +1395,7 @@ public:
int taskCount() const { return isTask() ? 1 : m_container.m_taskCount; } int taskCount() const { return isTask() ? 1 : m_container.m_taskCount; }
const GroupItem::TaskHandler m_taskHandler; const GroupItem::TaskHandler m_taskHandler;
TaskContainer m_container; ContainerNode m_container;
}; };
class TaskTreePrivate class TaskTreePrivate
@@ -1439,22 +1439,22 @@ public:
// If returned value != Continue, childDone() needs to be called in parent container (in caller) // If returned value != Continue, childDone() needs to be called in parent container (in caller)
// in order to unwind properly. // in order to unwind properly.
SetupResult start(TaskRuntimeNode *node); SetupResult start(RuntimeTask *node);
void stop(TaskRuntimeNode *node); void stop(RuntimeTask *node);
bool invokeDoneHandler(TaskRuntimeNode *node, DoneWith doneWith); bool invokeDoneHandler(RuntimeTask *node, DoneWith doneWith);
// Container related methods // Container related methods
SetupResult start(TaskRuntimeContainer *container); SetupResult start(RuntimeContainer *container);
SetupResult continueStart(TaskRuntimeContainer *container, SetupResult startAction, int nextChild); SetupResult continueStart(RuntimeContainer *container, SetupResult startAction, int nextChild);
SetupResult startChildren(TaskRuntimeContainer *container, int nextChild); SetupResult startChildren(RuntimeContainer *container, int nextChild);
SetupResult childDone(TaskRuntimeContainer *container, bool success); SetupResult childDone(RuntimeContainer *container, bool success);
void stop(TaskRuntimeContainer *container); void stop(RuntimeContainer *container);
bool invokeDoneHandler(TaskRuntimeContainer *container, DoneWith doneWith); bool invokeDoneHandler(RuntimeContainer *container, DoneWith doneWith);
template <typename Handler, typename ...Args, template <typename Handler, typename ...Args,
typename ReturnType = std::invoke_result_t<Handler, Args...>> typename ReturnType = std::invoke_result_t<Handler, Args...>>
ReturnType invokeHandler(TaskRuntimeContainer *container, Handler &&handler, Args &&...args) ReturnType invokeHandler(RuntimeContainer *container, Handler &&handler, Args &&...args)
{ {
ExecutionContextActivator activator(container); ExecutionContextActivator activator(container);
GuardLocker locker(m_guard); GuardLocker locker(m_guard);
@@ -1467,7 +1467,7 @@ public:
QSet<StorageBase> m_storages; QSet<StorageBase> m_storages;
QHash<StorageBase, StorageHandler> m_storageHandlers; QHash<StorageBase, StorageHandler> m_storageHandlers;
std::optional<TaskNode> m_root; std::optional<TaskNode> m_root;
std::unique_ptr<TaskRuntimeNode> m_runtimeRoot; // Keep me last in order to destruct first std::unique_ptr<RuntimeTask> m_runtimeRoot; // Keep me last in order to destruct first
}; };
static bool initialSuccessBit(WorkflowPolicy workflowPolicy) static bool initialSuccessBit(WorkflowPolicy workflowPolicy)
@@ -1487,68 +1487,68 @@ static bool initialSuccessBit(WorkflowPolicy workflowPolicy)
return false; return false;
} }
class TaskRuntimeContainer class RuntimeContainer
{ {
Q_DISABLE_COPY(TaskRuntimeContainer) Q_DISABLE_COPY(RuntimeContainer)
public: public:
TaskRuntimeContainer(const TaskContainer &taskContainer, TaskRuntimeNode *parentNode) RuntimeContainer(const ContainerNode &taskContainer, RuntimeTask *parentTask)
: m_taskContainer(taskContainer) : m_containerNode(taskContainer)
, m_parentNode(parentNode) , m_parentTask(parentTask)
, m_storages(createStorages(taskContainer)) , m_storages(createStorages(taskContainer))
, m_successBit(initialSuccessBit(taskContainer.m_workflowPolicy)) , m_successBit(initialSuccessBit(taskContainer.m_workflowPolicy))
{} {}
~TaskRuntimeContainer() ~RuntimeContainer()
{ {
for (int i = m_taskContainer.m_storageList.size() - 1; i >= 0; --i) { // iterate in reverse order for (int i = m_containerNode.m_storageList.size() - 1; i >= 0; --i) { // iterate in reverse order
const StorageBase storage = m_taskContainer.m_storageList[i]; const StorageBase storage = m_containerNode.m_storageList[i];
StoragePtr storagePtr = m_storages.value(i); StoragePtr storagePtr = m_storages.value(i);
if (m_callStorageDoneHandlersOnDestruction) if (m_callStorageDoneHandlersOnDestruction)
m_taskContainer.m_taskTreePrivate->callDoneHandler(storage, storagePtr); m_containerNode.m_taskTreePrivate->callDoneHandler(storage, storagePtr);
storage.m_storageData->m_destructor(storagePtr); storage.m_storageData->m_destructor(storagePtr);
} }
} }
static QList<StoragePtr> createStorages(const TaskContainer &container); static QList<StoragePtr> createStorages(const ContainerNode &container);
bool isStarting() const { return m_startGuard.isLocked(); } bool isStarting() const { return m_startGuard.isLocked(); }
int currentLimit() const; int currentLimit() const;
TaskRuntimeContainer *parentContainer() const; RuntimeContainer *parentContainer() const;
bool updateSuccessBit(bool success); bool updateSuccessBit(bool success);
void deleteChild(TaskRuntimeNode *node); void deleteChild(RuntimeTask *node);
const TaskContainer &m_taskContainer; // Not owning. const ContainerNode &m_containerNode; // Not owning.
TaskRuntimeNode *m_parentNode = nullptr; // Not owning. RuntimeTask *m_parentTask = nullptr; // Not owning.
const QList<StoragePtr> m_storages; const QList<StoragePtr> m_storages;
std::vector<std::unique_ptr<TaskRuntimeNode>> m_children; // Owning. std::vector<std::unique_ptr<RuntimeTask>> m_children; // Owning.
bool m_successBit = true; bool m_successBit = true;
bool m_callStorageDoneHandlersOnDestruction = false; bool m_callStorageDoneHandlersOnDestruction = false;
int m_doneCount = 0; int m_doneCount = 0;
Guard m_startGuard; Guard m_startGuard;
}; };
class TaskRuntimeNode class RuntimeTask
{ {
Q_DISABLE_COPY(TaskRuntimeNode) Q_DISABLE_COPY(RuntimeTask)
public: public:
TaskRuntimeNode(const TaskNode &taskNode, TaskRuntimeContainer *parentContainer) RuntimeTask(const TaskNode &taskNode, RuntimeContainer *parentContainer)
: m_taskNode(taskNode) : m_taskNode(taskNode)
, m_parentContainer(parentContainer) , m_parentContainer(parentContainer)
{} {}
const TaskNode &m_taskNode; // Not owning. const TaskNode &m_taskNode; // Not owning.
TaskRuntimeContainer *m_parentContainer = nullptr; // Not owning. RuntimeContainer *m_parentContainer = nullptr; // Not owning.
std::optional<TaskRuntimeContainer> m_container; // Owning. std::optional<RuntimeContainer> m_container; // Owning.
std::unique_ptr<TaskInterface> m_task; // Owning. std::unique_ptr<TaskInterface> m_task; // Owning.
}; };
void ExecutionContextActivator::activateContext(TaskRuntimeContainer *container) void ExecutionContextActivator::activateContext(RuntimeContainer *container)
{ {
const TaskContainer &taskContainer = container->m_taskContainer; const ContainerNode &containerNode = container->m_containerNode;
for (int i = 0; i < taskContainer.m_storageList.size(); ++i) { for (int i = 0; i < containerNode.m_storageList.size(); ++i) {
const StorageBase &storage = taskContainer.m_storageList[i]; const StorageBase &storage = containerNode.m_storageList[i];
if (m_activeStorages.contains(storage)) if (m_activeStorages.contains(storage))
continue; // Storage shadowing: The storage is already active, skipping it... continue; // Storage shadowing: The storage is already active, skipping it...
m_activeStorages.append(storage); m_activeStorages.append(storage);
@@ -1571,7 +1571,7 @@ void TaskTreePrivate::start()
QT_ASSERT(m_storages.contains(it.key()), qWarning("The registered storage doesn't " QT_ASSERT(m_storages.contains(it.key()), qWarning("The registered storage doesn't "
"exist in task tree. Its handlers will never be called.")); "exist in task tree. Its handlers will never be called."));
} }
m_runtimeRoot.reset(new TaskRuntimeNode(*m_root, nullptr)); m_runtimeRoot.reset(new RuntimeTask(*m_root, nullptr));
start(m_runtimeRoot.get()); start(m_runtimeRoot.get());
} }
@@ -1624,7 +1624,7 @@ static std::vector<TaskNode> createChildren(TaskTreePrivate *taskTreePrivate,
return result; return result;
} }
TaskContainer::TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task) ContainerNode::ContainerNode(TaskTreePrivate *taskTreePrivate, const GroupItem &task)
: m_taskTreePrivate(taskTreePrivate) : m_taskTreePrivate(taskTreePrivate)
, m_parallelLimit(task.m_groupData.m_parallelLimit.value_or(1)) , m_parallelLimit(task.m_groupData.m_parallelLimit.value_or(1))
, m_workflowPolicy(task.m_groupData.m_workflowPolicy.value_or(WorkflowPolicy::StopOnError)) , m_workflowPolicy(task.m_groupData.m_workflowPolicy.value_or(WorkflowPolicy::StopOnError))
@@ -1638,7 +1638,7 @@ TaskContainer::TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &
m_taskTreePrivate->m_storages << storage; m_taskTreePrivate->m_storages << storage;
} }
QList<StoragePtr> TaskRuntimeContainer::createStorages(const TaskContainer &container) QList<StoragePtr> RuntimeContainer::createStorages(const ContainerNode &container)
{ {
QList<StoragePtr> storages; QList<StoragePtr> storages;
for (const StorageBase &storage : container.m_storageList) { for (const StorageBase &storage : container.m_storageList) {
@@ -1649,58 +1649,58 @@ QList<StoragePtr> TaskRuntimeContainer::createStorages(const TaskContainer &cont
return storages; return storages;
} }
int TaskRuntimeContainer::currentLimit() const int RuntimeContainer::currentLimit() const
{ {
// TODO: Handle children well // TODO: Handle children well
const int childCount = int(m_taskContainer.m_children.size()); const int childCount = int(m_containerNode.m_children.size());
return m_taskContainer.m_parallelLimit return m_containerNode.m_parallelLimit
? qMin(m_doneCount + m_taskContainer.m_parallelLimit, childCount) : childCount; ? qMin(m_doneCount + m_containerNode.m_parallelLimit, childCount) : childCount;
} }
TaskRuntimeContainer *TaskRuntimeContainer::parentContainer() const RuntimeContainer *RuntimeContainer::parentContainer() const
{ {
return m_parentNode->m_parentContainer; return m_parentTask->m_parentContainer;
} }
bool TaskRuntimeContainer::updateSuccessBit(bool success) bool RuntimeContainer::updateSuccessBit(bool success)
{ {
if (m_taskContainer.m_workflowPolicy == WorkflowPolicy::FinishAllAndSuccess if (m_containerNode.m_workflowPolicy == WorkflowPolicy::FinishAllAndSuccess
|| m_taskContainer.m_workflowPolicy == WorkflowPolicy::FinishAllAndError || m_containerNode.m_workflowPolicy == WorkflowPolicy::FinishAllAndError
|| m_taskContainer.m_workflowPolicy == WorkflowPolicy::StopOnSuccessOrError) { || m_containerNode.m_workflowPolicy == WorkflowPolicy::StopOnSuccessOrError) {
if (m_taskContainer.m_workflowPolicy == WorkflowPolicy::StopOnSuccessOrError) if (m_containerNode.m_workflowPolicy == WorkflowPolicy::StopOnSuccessOrError)
m_successBit = success; m_successBit = success;
return m_successBit; return m_successBit;
} }
const bool donePolicy = m_taskContainer.m_workflowPolicy == WorkflowPolicy::StopOnSuccess const bool donePolicy = m_containerNode.m_workflowPolicy == WorkflowPolicy::StopOnSuccess
|| m_taskContainer.m_workflowPolicy == WorkflowPolicy::ContinueOnSuccess; || m_containerNode.m_workflowPolicy == WorkflowPolicy::ContinueOnSuccess;
m_successBit = donePolicy ? (m_successBit || success) : (m_successBit && success); m_successBit = donePolicy ? (m_successBit || success) : (m_successBit && success);
return m_successBit; return m_successBit;
} }
void TaskRuntimeContainer::deleteChild(TaskRuntimeNode *node) void RuntimeContainer::deleteChild(RuntimeTask *task)
{ {
const auto it = std::find_if(m_children.cbegin(), m_children.cend(), [node](const auto &ptr) { const auto it = std::find_if(m_children.cbegin(), m_children.cend(), [task](const auto &ptr) {
return ptr.get() == node; return ptr.get() == task;
}); });
if (it != m_children.cend()) if (it != m_children.cend())
m_children.erase(it); m_children.erase(it);
} }
SetupResult TaskTreePrivate::start(TaskRuntimeContainer *container) SetupResult TaskTreePrivate::start(RuntimeContainer *container)
{ {
SetupResult startAction = SetupResult::Continue; SetupResult startAction = SetupResult::Continue;
if (container->m_taskContainer.m_groupHandler.m_setupHandler) { if (container->m_containerNode.m_groupHandler.m_setupHandler) {
startAction = invokeHandler(container, container->m_taskContainer.m_groupHandler.m_setupHandler); startAction = invokeHandler(container, container->m_containerNode.m_groupHandler.m_setupHandler);
if (startAction != SetupResult::Continue) { if (startAction != SetupResult::Continue) {
// TODO: Handle progress well. // TODO: Handle progress well.
advanceProgress(container->m_taskContainer.m_taskCount); advanceProgress(container->m_containerNode.m_taskCount);
// Non-Continue SetupResult takes precedence over the workflow policy. // Non-Continue SetupResult takes precedence over the workflow policy.
container->m_successBit = startAction == SetupResult::StopWithSuccess; container->m_successBit = startAction == SetupResult::StopWithSuccess;
} }
} }
if (startAction == SetupResult::Continue) { if (startAction == SetupResult::Continue) {
if (container->m_taskContainer.m_children.empty()) if (container->m_containerNode.m_children.empty())
startAction = toSetupResult(container->m_successBit); startAction = toSetupResult(container->m_successBit);
} else { // TODO: Check if repeater exists, call its handler. } else { // TODO: Check if repeater exists, call its handler.
@@ -1708,22 +1708,22 @@ SetupResult TaskTreePrivate::start(TaskRuntimeContainer *container)
return continueStart(container, startAction, 0); return continueStart(container, startAction, 0);
} }
SetupResult TaskTreePrivate::continueStart(TaskRuntimeContainer *container, SetupResult startAction, int nextChild) SetupResult TaskTreePrivate::continueStart(RuntimeContainer *container, SetupResult startAction, int nextChild)
{ {
const SetupResult groupAction = startAction == SetupResult::Continue ? startChildren(container, nextChild) const SetupResult groupAction = startAction == SetupResult::Continue ? startChildren(container, nextChild)
: startAction; : startAction;
if (groupAction != SetupResult::Continue) { if (groupAction != SetupResult::Continue) {
const bool bit = container->updateSuccessBit(groupAction == SetupResult::StopWithSuccess); const bool bit = container->updateSuccessBit(groupAction == SetupResult::StopWithSuccess);
TaskRuntimeContainer *parentContainer = container->parentContainer(); RuntimeContainer *parentContainer = container->parentContainer();
TaskRuntimeNode *parentNode = container->m_parentNode; RuntimeTask *parentTask = container->m_parentTask;
QT_CHECK(parentNode); QT_CHECK(parentTask);
const bool result = invokeDoneHandler(container, bit ? DoneWith::Success : DoneWith::Error); const bool result = invokeDoneHandler(container, bit ? DoneWith::Success : DoneWith::Error);
if (parentContainer) { if (parentContainer) {
parentContainer->deleteChild(parentNode); parentContainer->deleteChild(parentTask);
if (!parentContainer->isStarting()) if (!parentContainer->isStarting())
childDone(parentContainer, result); childDone(parentContainer, result);
} else { } else {
QT_CHECK(m_runtimeRoot.get() == parentNode); QT_CHECK(m_runtimeRoot.get() == parentTask);
m_runtimeRoot.reset(); m_runtimeRoot.reset();
emitDone(result ? DoneWith::Success : DoneWith::Error); emitDone(result ? DoneWith::Success : DoneWith::Error);
} }
@@ -1731,15 +1731,15 @@ SetupResult TaskTreePrivate::continueStart(TaskRuntimeContainer *container, Setu
return groupAction; return groupAction;
} }
SetupResult TaskTreePrivate::startChildren(TaskRuntimeContainer *container, int nextChild) SetupResult TaskTreePrivate::startChildren(RuntimeContainer *container, int nextChild)
{ {
GuardLocker locker(container->m_startGuard); GuardLocker locker(container->m_startGuard);
for (int i = nextChild; i < int(container->m_taskContainer.m_children.size()); ++i) { for (int i = nextChild; i < int(container->m_containerNode.m_children.size()); ++i) {
const int limit = container->currentLimit(); const int limit = container->currentLimit();
if (i >= limit) if (i >= limit)
break; break;
TaskRuntimeNode *newTask = new TaskRuntimeNode(container->m_taskContainer.m_children.at(i), container); RuntimeTask *newTask = new RuntimeTask(container->m_containerNode.m_children.at(i), container);
container->m_children.emplace_back(newTask); container->m_children.emplace_back(newTask);
const SetupResult startAction = start(newTask); const SetupResult startAction = start(newTask);
@@ -1753,7 +1753,7 @@ SetupResult TaskTreePrivate::startChildren(TaskRuntimeContainer *container, int
int skippedTaskCount = 0; int skippedTaskCount = 0;
// Skip scheduled but not run yet. The current (i) was already notified. // Skip scheduled but not run yet. The current (i) was already notified.
for (int j = i + 1; j < limit; ++j) for (int j = i + 1; j < limit; ++j)
skippedTaskCount += container->m_taskContainer.m_children.at(j).taskCount(); skippedTaskCount += container->m_containerNode.m_children.at(j).taskCount();
// TODO: Handle progress well // TODO: Handle progress well
advanceProgress(skippedTaskCount); advanceProgress(skippedTaskCount);
return finalizeAction; return finalizeAction;
@@ -1761,10 +1761,10 @@ SetupResult TaskTreePrivate::startChildren(TaskRuntimeContainer *container, int
return SetupResult::Continue; return SetupResult::Continue;
} }
SetupResult TaskTreePrivate::childDone(TaskRuntimeContainer *container, bool success) SetupResult TaskTreePrivate::childDone(RuntimeContainer *container, bool success)
{ {
const int limit = container->currentLimit(); // Read before bumping m_doneCount and stop() const int limit = container->currentLimit(); // Read before bumping m_doneCount and stop()
const WorkflowPolicy &workflowPolicy = container->m_taskContainer.m_workflowPolicy; const WorkflowPolicy &workflowPolicy = container->m_containerNode.m_workflowPolicy;
const bool shouldStop = workflowPolicy == WorkflowPolicy::StopOnSuccessOrError const bool shouldStop = workflowPolicy == WorkflowPolicy::StopOnSuccessOrError
|| (workflowPolicy == WorkflowPolicy::StopOnSuccess && success) || (workflowPolicy == WorkflowPolicy::StopOnSuccess && success)
|| (workflowPolicy == WorkflowPolicy::StopOnError && !success); || (workflowPolicy == WorkflowPolicy::StopOnError && !success);
@@ -1774,7 +1774,7 @@ SetupResult TaskTreePrivate::childDone(TaskRuntimeContainer *container, bool suc
++container->m_doneCount; ++container->m_doneCount;
const bool updatedSuccess = container->updateSuccessBit(success); const bool updatedSuccess = container->updateSuccessBit(success);
const SetupResult startAction const SetupResult startAction
= (shouldStop || container->m_doneCount == int(container->m_taskContainer.m_children.size())) = (shouldStop || container->m_doneCount == int(container->m_containerNode.m_children.size()))
? toSetupResult(updatedSuccess) : SetupResult::Continue; ? toSetupResult(updatedSuccess) : SetupResult::Continue;
if (container->isStarting()) if (container->isStarting())
@@ -1782,7 +1782,7 @@ SetupResult TaskTreePrivate::childDone(TaskRuntimeContainer *container, bool suc
return continueStart(container, startAction, limit); return continueStart(container, startAction, limit);
} }
void TaskTreePrivate::stop(TaskRuntimeContainer *container) void TaskTreePrivate::stop(RuntimeContainer *container)
{ {
for (auto &child : container->m_children) { for (auto &child : container->m_children) {
if (child) if (child)
@@ -1790,8 +1790,8 @@ void TaskTreePrivate::stop(TaskRuntimeContainer *container)
} }
int skippedTaskCount = 0; int skippedTaskCount = 0;
for (int i = container->currentLimit(); i < int(container->m_taskContainer.m_children.size()); ++i) for (int i = container->currentLimit(); i < int(container->m_containerNode.m_children.size()); ++i)
skippedTaskCount += container->m_taskContainer.m_children.at(i).taskCount(); skippedTaskCount += container->m_containerNode.m_children.at(i).taskCount();
// TODO: Handle progress well // TODO: Handle progress well
advanceProgress(skippedTaskCount); advanceProgress(skippedTaskCount);
@@ -1804,18 +1804,18 @@ static bool shouldCall(CallDoneIf callDoneIf, DoneWith result)
return callDoneIf != CallDoneIf::Success; return callDoneIf != CallDoneIf::Success;
} }
bool TaskTreePrivate::invokeDoneHandler(TaskRuntimeContainer *container, DoneWith doneWith) bool TaskTreePrivate::invokeDoneHandler(RuntimeContainer *container, DoneWith doneWith)
{ {
DoneResult result = toDoneResult(doneWith); DoneResult result = toDoneResult(doneWith);
const GroupItem::GroupHandler &groupHandler = container->m_taskContainer.m_groupHandler; const GroupItem::GroupHandler &groupHandler = container->m_containerNode.m_groupHandler;
if (groupHandler.m_doneHandler && shouldCall(groupHandler.m_callDoneIf, doneWith)) if (groupHandler.m_doneHandler && shouldCall(groupHandler.m_callDoneIf, doneWith))
result = invokeHandler(container, groupHandler.m_doneHandler, doneWith); result = invokeHandler(container, groupHandler.m_doneHandler, doneWith);
container->m_callStorageDoneHandlersOnDestruction = true; container->m_callStorageDoneHandlersOnDestruction = true;
container->m_parentNode->m_container.reset(); container->m_parentTask->m_container.reset();
return result == DoneResult::Success; return result == DoneResult::Success;
} }
SetupResult TaskTreePrivate::start(TaskRuntimeNode *node) SetupResult TaskTreePrivate::start(RuntimeTask *node)
{ {
if (!node->m_taskNode.isTask()) { if (!node->m_taskNode.isTask()) {
node->m_container.emplace(node->m_taskNode.m_container, node); node->m_container.emplace(node->m_taskNode.m_container, node);
@@ -1840,7 +1840,7 @@ SetupResult TaskTreePrivate::start(TaskRuntimeNode *node)
const bool result = invokeDoneHandler(node, toDoneWith(doneResult)); const bool result = invokeDoneHandler(node, toDoneWith(doneResult));
QObject::disconnect(node->m_task.get(), &TaskInterface::done, q, nullptr); QObject::disconnect(node->m_task.get(), &TaskInterface::done, q, nullptr);
node->m_task.release()->deleteLater(); node->m_task.release()->deleteLater();
TaskRuntimeContainer *parentContainer = node->m_parentContainer; RuntimeContainer *parentContainer = node->m_parentContainer;
parentContainer->deleteChild(node); parentContainer->deleteChild(node);
if (parentContainer->isStarting()) if (parentContainer->isStarting())
*unwindAction = toSetupResult(result); *unwindAction = toSetupResult(result);
@@ -1852,7 +1852,7 @@ SetupResult TaskTreePrivate::start(TaskRuntimeNode *node)
return *unwindAction; return *unwindAction;
} }
void TaskTreePrivate::stop(TaskRuntimeNode *node) void TaskTreePrivate::stop(RuntimeTask *node)
{ {
if (!node->m_task) { if (!node->m_task) {
if (!node->m_container) if (!node->m_container)
@@ -1867,7 +1867,7 @@ void TaskTreePrivate::stop(TaskRuntimeNode *node)
node->m_task.reset(); node->m_task.reset();
} }
bool TaskTreePrivate::invokeDoneHandler(TaskRuntimeNode *node, DoneWith doneWith) bool TaskTreePrivate::invokeDoneHandler(RuntimeTask *node, DoneWith doneWith)
{ {
DoneResult result = toDoneResult(doneWith); DoneResult result = toDoneResult(doneWith);
const GroupItem::TaskHandler &handler = node->m_taskNode.m_taskHandler; const GroupItem::TaskHandler &handler = node->m_taskNode.m_taskHandler;

4
src/libs/solutions/tasking/tasktree.h
View File

@@ -121,7 +121,7 @@ private:
template <typename StorageStruct> friend class Storage; template <typename StorageStruct> friend class Storage;
friend class ExecutionContextActivator; friend class ExecutionContextActivator;
friend class StorageData; friend class StorageData;
friend class TaskRuntimeContainer; friend class RuntimeContainer;
friend class TaskTree; friend class TaskTree;
friend class TaskTreePrivate; friend class TaskTreePrivate;
}; };
@@ -224,7 +224,7 @@ protected:
} }
private: private:
friend class TaskContainer; friend class ContainerNode;
friend class TaskNode; friend class TaskNode;
friend class TaskTreePrivate; friend class TaskTreePrivate;
Type m_type = Type::Group; Type m_type = Type::Group;