From c098b261dc54fa8edbdd2bde17841cfe8b7e64a0 Mon Sep 17 00:00:00 2001 From: Jarek Kobus Date: Thu, 18 May 2023 13:16:40 +0200 Subject: [PATCH] TaskTree: Refactor Group internal data Introduce the GroupData structure. In this way it's easily possible to add extra properties of already used types, e.g. int. It's also possible to easily create elements with multiple properties. Simplify internal TaskItem::Type enum. Get rid of special ParallelLimit and Workflow elements. Provide global parallelLimit() and workflowPolicy() functions. Make global items (e.g. parallel, stopOnDone, etc...) const. Change-Id: Ic5628255b542fd6c5a5565b055ff11804c8d7b68 Reviewed-by: Qt CI Bot Reviewed-by: Reviewed-by: hjk --- src/libs/solutions/tasking/tasktree.cpp | 93 +++++++++++-------- src/libs/solutions/tasking/tasktree.h | 93 ++++++++----------- src/plugins/autotest/testcodeparser.cpp | 2 +- .../clangtools/clangtoolruncontrol.cpp | 2 +- .../coreplugin/locator/ilocatorfilter.cpp | 2 +- .../qnx/qnxdeployqtlibrariesdialog.cpp | 2 +- .../remotelinux/genericdirectuploadstep.cpp | 4 +- tests/auto/solutions/tasking/tst_tasking.cpp | 34 +++---- tests/manual/tasktree/main.cpp | 8 +- tests/manual/tasktree/taskwidget.cpp | 2 +- tests/manual/tasktree/taskwidget.h | 2 +- 11 files changed, 121 insertions(+), 123 deletions(-) diff --git a/src/libs/solutions/tasking/tasktree.cpp b/src/libs/solutions/tasking/tasktree.cpp index 57429b90516..4e9cab7bb90 100644 --- a/src/libs/solutions/tasking/tasktree.cpp +++ b/src/libs/solutions/tasking/tasktree.cpp @@ -50,6 +50,25 @@ TaskItem onGroupError(const TaskItem::GroupEndHandler &handler) return Group::onGroupError(handler); } +TaskItem parallelLimit(int limit) +{ + return Group::parallelLimit(qMax(limit, 0)); +} + +TaskItem workflowPolicy(WorkflowPolicy policy) +{ + return Group::workflowPolicy(policy); +} + +const TaskItem sequential = parallelLimit(1); +const TaskItem parallel = parallelLimit(0); +const TaskItem stopOnError = workflowPolicy(WorkflowPolicy::StopOnError); +const TaskItem continueOnError = workflowPolicy(WorkflowPolicy::ContinueOnError); +const TaskItem stopOnDone = workflowPolicy(WorkflowPolicy::StopOnDone); +const TaskItem continueOnDone = workflowPolicy(WorkflowPolicy::ContinueOnDone); +const TaskItem stopOnFinished = workflowPolicy(WorkflowPolicy::StopOnFinished); +const TaskItem optional = workflowPolicy(WorkflowPolicy::Optional); + static TaskAction toTaskAction(bool success) { return success ? TaskAction::StopWithDone : TaskAction::StopWithError; @@ -118,15 +137,6 @@ void TreeStorageBase::activateStorage(int id) const m_storageData->m_activeStorage = id; } -ParallelLimit sequential(1); -ParallelLimit parallel(0); -Workflow stopOnError(WorkflowPolicy::StopOnError); -Workflow continueOnError(WorkflowPolicy::ContinueOnError); -Workflow stopOnDone(WorkflowPolicy::StopOnDone); -Workflow continueOnDone(WorkflowPolicy::ContinueOnDone); -Workflow stopOnFinished(WorkflowPolicy::StopOnFinished); -Workflow optional(WorkflowPolicy::Optional); - void TaskItem::addChildren(const QList &children) { QTC_ASSERT(m_type == Type::Group, qWarning("Only Group may have children, skipping..."); @@ -136,40 +146,41 @@ void TaskItem::addChildren(const QList &children) case Type::Group: m_children.append(child); break; - case Type::Limit: - QTC_ASSERT(m_type == Type::Group, qWarning("Execution Mode may only be a child of a " - "Group, skipping..."); return); - m_parallelLimit = child.m_parallelLimit; // TODO: Assert on redefinition? - break; - case Type::Policy: - QTC_ASSERT(m_type == Type::Group, qWarning("Workflow Policy may only be a child of a " - "Group, skipping..."); return); - m_workflowPolicy = child.m_workflowPolicy; // TODO: Assert on redefinition? + case Type::GroupData: + if (child.m_groupData.m_groupHandler.m_setupHandler) { + QTC_ASSERT(!m_groupData.m_groupHandler.m_setupHandler, + qWarning("Group Setup Handler redefinition, overriding...")); + m_groupData.m_groupHandler.m_setupHandler + = child.m_groupData.m_groupHandler.m_setupHandler; + } + if (child.m_groupData.m_groupHandler.m_doneHandler) { + QTC_ASSERT(!m_groupData.m_groupHandler.m_doneHandler, + qWarning("Group Done Handler redefinition, overriding...")); + m_groupData.m_groupHandler.m_doneHandler + = child.m_groupData.m_groupHandler.m_doneHandler; + } + if (child.m_groupData.m_groupHandler.m_errorHandler) { + QTC_ASSERT(!m_groupData.m_groupHandler.m_errorHandler, + qWarning("Group Error Handler redefinition, overriding...")); + m_groupData.m_groupHandler.m_errorHandler + = child.m_groupData.m_groupHandler.m_errorHandler; + } + if (child.m_groupData.m_parallelLimit) { + QTC_ASSERT(!m_groupData.m_parallelLimit, + qWarning("Group Execution Mode redefinition, overriding...")); + m_groupData.m_parallelLimit = child.m_groupData.m_parallelLimit; + } + if (child.m_groupData.m_workflowPolicy) { + QTC_ASSERT(!m_groupData.m_workflowPolicy, + qWarning("Group Workflow Policy redefinition, overriding...")); + m_groupData.m_workflowPolicy = child.m_groupData.m_workflowPolicy; + } break; case Type::TaskHandler: QTC_ASSERT(child.m_taskHandler.m_createHandler, qWarning("Task Create Handler can't be null, skipping..."); return); m_children.append(child); break; - case Type::GroupHandler: - QTC_ASSERT(m_type == Type::Group, qWarning("Group Handler may only be a " - "child of a Group, skipping..."); break); - QTC_ASSERT(!child.m_groupHandler.m_setupHandler - || !m_groupHandler.m_setupHandler, - qWarning("Group Setup Handler redefinition, overriding...")); - QTC_ASSERT(!child.m_groupHandler.m_doneHandler - || !m_groupHandler.m_doneHandler, - qWarning("Group Done Handler redefinition, overriding...")); - QTC_ASSERT(!child.m_groupHandler.m_errorHandler - || !m_groupHandler.m_errorHandler, - qWarning("Group Error Handler redefinition, overriding...")); - if (child.m_groupHandler.m_setupHandler) - m_groupHandler.m_setupHandler = child.m_groupHandler.m_setupHandler; - if (child.m_groupHandler.m_doneHandler) - m_groupHandler.m_doneHandler = child.m_groupHandler.m_doneHandler; - if (child.m_groupHandler.m_errorHandler) - m_groupHandler.m_errorHandler = child.m_groupHandler.m_errorHandler; - break; case Type::Storage: m_storageList.append(child.m_storageList); break; @@ -472,9 +483,9 @@ TaskContainer::ConstData::ConstData(TaskTreePrivate *taskTreePrivate, const Task : m_taskTreePrivate(taskTreePrivate) , m_parentNode(parentNode) , m_parentContainer(parentContainer) - , m_parallelLimit(task.parallelLimit()) - , m_workflowPolicy(task.workflowPolicy()) - , m_groupHandler(task.groupHandler()) + , m_parallelLimit(task.groupData().m_parallelLimit.value_or(1)) + , m_workflowPolicy(task.groupData().m_workflowPolicy.value_or(WorkflowPolicy::StopOnError)) + , m_groupHandler(task.groupData().m_groupHandler) , m_storageList(taskTreePrivate->addStorages(task.storageList())) , m_children(createChildren(taskTreePrivate, thisContainer, task)) , m_taskCount(std::accumulate(m_children.cbegin(), m_children.cend(), 0, @@ -1130,7 +1141,7 @@ void TaskNode::invokeEndHandler(bool success) started, without waiting for the previous tasks to finish. In this mode, all tasks run simultaneously. \row - \li ParallelLimit(int limit) + \li parallelLimit(int limit) \li In this mode, a limited number of direct child tasks run simultaneously. The \e limit defines the maximum number of tasks running in parallel in a group. When the group is started, the first batch tasks is diff --git a/src/libs/solutions/tasking/tasktree.h b/src/libs/solutions/tasking/tasktree.h index 7b37c36eb90..1754e092631 100644 --- a/src/libs/solutions/tasking/tasktree.h +++ b/src/libs/solutions/tasking/tasktree.h @@ -18,7 +18,6 @@ namespace Tasking { class ExecutionContextActivator; class TaskContainer; -class TaskNode; class TaskTreePrivate; class TASKING_EXPORT TaskInterface : public QObject @@ -68,9 +67,9 @@ private: int m_storageCounter = 0; }; QSharedPointer m_storageData; + friend ExecutionContextActivator; friend TaskContainer; friend TaskTreePrivate; - friend ExecutionContextActivator; }; template @@ -145,54 +144,50 @@ public: GroupEndHandler m_errorHandler = {}; }; - int parallelLimit() const { return m_parallelLimit; } - WorkflowPolicy workflowPolicy() const { return m_workflowPolicy; } - TaskHandler taskHandler() const { return m_taskHandler; } - GroupHandler groupHandler() const { return m_groupHandler; } + struct GroupData { + GroupHandler m_groupHandler = {}; + std::optional m_parallelLimit = {}; + std::optional m_workflowPolicy = {}; + }; + QList children() const { return m_children; } + GroupData groupData() const { return m_groupData; } QList storageList() const { return m_storageList; } + TaskHandler taskHandler() const { return m_taskHandler; } protected: enum class Type { Group, + GroupData, Storage, - Limit, - Policy, - TaskHandler, - GroupHandler + TaskHandler }; TaskItem() = default; - TaskItem(int parallelLimit) - : m_type(Type::Limit) - , m_parallelLimit(parallelLimit) {} - TaskItem(WorkflowPolicy policy) - : m_type(Type::Policy) - , m_workflowPolicy(policy) {} - TaskItem(const TaskHandler &handler) - : m_type(Type::TaskHandler) - , m_taskHandler(handler) {} - TaskItem(const GroupHandler &handler) - : m_type(Type::GroupHandler) - , m_groupHandler(handler) {} + TaskItem(const GroupData &data) + : m_type(Type::GroupData) + , m_groupData(data) {} TaskItem(const TreeStorageBase &storage) : m_type(Type::Storage) , m_storageList{storage} {} + TaskItem(const TaskHandler &handler) + : m_type(Type::TaskHandler) + , m_taskHandler(handler) {} void addChildren(const QList &children); void setTaskSetupHandler(const TaskSetupHandler &handler); void setTaskDoneHandler(const TaskEndHandler &handler); void setTaskErrorHandler(const TaskEndHandler &handler); - static TaskItem createGroupHandler(const GroupHandler &handler) { return TaskItem(handler); } + static TaskItem groupHandler(const GroupHandler &handler) { return TaskItem({handler}); } + static TaskItem parallelLimit(int limit) { return TaskItem({{}, limit}); } + static TaskItem workflowPolicy(WorkflowPolicy policy) { return TaskItem({{}, {}, policy}); } private: Type m_type = Type::Group; - int m_parallelLimit = 1; // 0 means unlimited - WorkflowPolicy m_workflowPolicy = WorkflowPolicy::StopOnError; - TaskHandler m_taskHandler; - GroupHandler m_groupHandler; - QList m_storageList; QList m_children; + GroupData m_groupData; + QList m_storageList; + TaskHandler m_taskHandler; }; class TASKING_EXPORT Group : public TaskItem @@ -201,16 +196,19 @@ public: Group(const QList &children) { addChildren(children); } Group(std::initializer_list children) { addChildren(children); } + // GroupData related: template static TaskItem onGroupSetup(SetupHandler &&handler) { - return createGroupHandler({wrapGroupSetup(std::forward(handler))}); + return groupHandler({wrapGroupSetup(std::forward(handler))}); } static TaskItem onGroupDone(const GroupEndHandler &handler) { - return createGroupHandler({{}, handler}); + return groupHandler({{}, handler}); } static TaskItem onGroupError(const GroupEndHandler &handler) { - return createGroupHandler({{}, {}, handler}); + return groupHandler({{}, {}, handler}); } + using TaskItem::parallelLimit; // Default: 1 (sequential). 0 means unlimited (parallel). + using TaskItem::workflowPolicy; // Default: WorkflowPolicy::StopOnError. private: template @@ -240,6 +238,17 @@ static TaskItem onGroupSetup(SetupHandler &&handler) TASKING_EXPORT TaskItem onGroupDone(const TaskItem::GroupEndHandler &handler); TASKING_EXPORT TaskItem onGroupError(const TaskItem::GroupEndHandler &handler); +TASKING_EXPORT TaskItem parallelLimit(int limit); +TASKING_EXPORT TaskItem workflowPolicy(WorkflowPolicy policy); + +TASKING_EXPORT extern const TaskItem sequential; +TASKING_EXPORT extern const TaskItem parallel; +TASKING_EXPORT extern const TaskItem stopOnError; +TASKING_EXPORT extern const TaskItem continueOnError; +TASKING_EXPORT extern const TaskItem stopOnDone; +TASKING_EXPORT extern const TaskItem continueOnDone; +TASKING_EXPORT extern const TaskItem stopOnFinished; +TASKING_EXPORT extern const TaskItem optional; class TASKING_EXPORT Storage : public TaskItem { @@ -247,18 +256,6 @@ public: Storage(const TreeStorageBase &storage) : TaskItem(storage) { } }; -class TASKING_EXPORT ParallelLimit : public TaskItem -{ -public: - ParallelLimit(int parallelLimit) : TaskItem(qMax(parallelLimit, 0)) {} -}; - -class TASKING_EXPORT Workflow : public TaskItem -{ -public: - Workflow(WorkflowPolicy policy) : TaskItem(policy) {} -}; - // Synchronous invocation. Similarly to Group - isn't counted as a task inside taskCount() class TASKING_EXPORT Sync : public Group { @@ -283,18 +280,8 @@ private: } return {onGroupSetup([function] { function(); return TaskAction::StopWithDone; })}; }; - }; -TASKING_EXPORT extern ParallelLimit sequential; -TASKING_EXPORT extern ParallelLimit parallel; -TASKING_EXPORT extern Workflow stopOnError; -TASKING_EXPORT extern Workflow continueOnError; -TASKING_EXPORT extern Workflow stopOnDone; -TASKING_EXPORT extern Workflow continueOnDone; -TASKING_EXPORT extern Workflow stopOnFinished; -TASKING_EXPORT extern Workflow optional; - template class TaskAdapter : public TaskInterface { diff --git a/src/plugins/autotest/testcodeparser.cpp b/src/plugins/autotest/testcodeparser.cpp index 6f3d5137e45..8553702432f 100644 --- a/src/plugins/autotest/testcodeparser.cpp +++ b/src/plugins/autotest/testcodeparser.cpp @@ -360,7 +360,7 @@ void TestCodeParser::scanForTests(const QSet &filePaths, using namespace Tasking; - QList tasks{ParallelLimit(std::max(QThread::idealThreadCount() / 4, 1))}; + QList tasks{parallelLimit(std::max(QThread::idealThreadCount() / 4, 1))}; for (const FilePath &file : filteredFiles) { const auto setup = [this, codeParsers, file](Async &async) { async.setConcurrentCallData(parseFileForTests, codeParsers, file); diff --git a/src/plugins/clangtools/clangtoolruncontrol.cpp b/src/plugins/clangtools/clangtoolruncontrol.cpp index be6f416d2e0..11353b04ae4 100644 --- a/src/plugins/clangtools/clangtoolruncontrol.cpp +++ b/src/plugins/clangtools/clangtoolruncontrol.cpp @@ -183,7 +183,7 @@ void ClangToolRunWorker::start() m_filesAnalyzed.clear(); m_filesNotAnalyzed.clear(); - QList tasks{ParallelLimit(qMax(1, m_runSettings.parallelJobs()))}; + QList tasks{parallelLimit(qMax(1, m_runSettings.parallelJobs()))}; for (const AnalyzeUnit &unit : std::as_const(unitsToProcess)) { if (!m_diagnosticConfig.isEnabled(tool) && !m_runSettings.hasConfigFileForSourceFile(unit.file)) { diff --git a/src/plugins/coreplugin/locator/ilocatorfilter.cpp b/src/plugins/coreplugin/locator/ilocatorfilter.cpp index 3c0ab0a5659..930b2c918d9 100644 --- a/src/plugins/coreplugin/locator/ilocatorfilter.cpp +++ b/src/plugins/coreplugin/locator/ilocatorfilter.cpp @@ -450,7 +450,7 @@ void LocatorMatcher::start() collectorStorage->m_collector = nullptr; }; - QList parallelTasks { ParallelLimit(d->m_parallelLimit) }; + QList parallelTasks {parallelLimit(d->m_parallelLimit)}; const auto onSetup = [this, collectorStorage](const TreeStorage &storage, int index) { diff --git a/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp b/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp index 768553ff7a7..0b6e74dca8b 100644 --- a/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp +++ b/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp @@ -223,7 +223,7 @@ TaskItem QnxDeployQtLibrariesDialogPrivate::chmodTree() if (file.isExecutable()) filesToChmod << file; } - QList chmodList{optional, ParallelLimit(MaxConcurrentStatCalls)}; + QList chmodList{optional, parallelLimit(MaxConcurrentStatCalls)}; for (const DeployableFile &file : std::as_const(filesToChmod)) { QTC_ASSERT(file.isValid(), continue); chmodList.append(chmodTask(file)); diff --git a/src/plugins/remotelinux/genericdirectuploadstep.cpp b/src/plugins/remotelinux/genericdirectuploadstep.cpp index 586fc8bafd4..9179ac87519 100644 --- a/src/plugins/remotelinux/genericdirectuploadstep.cpp +++ b/src/plugins/remotelinux/genericdirectuploadstep.cpp @@ -179,7 +179,7 @@ TaskItem GenericDirectUploadStep::statTree(const TreeStorage &sto const auto setupHandler = [=](TaskTree &tree) { UploadStorage *storagePtr = storage.activeStorage(); const QList files = filesToStat(storagePtr); - QList statList{optional, ParallelLimit(MaxConcurrentStatCalls)}; + QList statList{optional, parallelLimit(MaxConcurrentStatCalls)}; for (const DeployableFile &file : std::as_const(files)) { QTC_ASSERT(file.isValid(), continue); statList.append(statTask(storagePtr, file, statEndHandler)); @@ -256,7 +256,7 @@ TaskItem GenericDirectUploadStep::chmodTree(const TreeStorage &st if (file.isExecutable()) filesToChmod << file; } - QList chmodList{optional, ParallelLimit(MaxConcurrentStatCalls)}; + QList chmodList{optional, parallelLimit(MaxConcurrentStatCalls)}; for (const DeployableFile &file : std::as_const(filesToChmod)) { QTC_ASSERT(file.isValid(), continue); chmodList.append(chmodTask(file)); diff --git a/tests/auto/solutions/tasking/tst_tasking.cpp b/tests/auto/solutions/tasking/tst_tasking.cpp index a94c449dfc6..fb8e575322f 100644 --- a/tests/auto/solutions/tasking/tst_tasking.cpp +++ b/tests/auto/solutions/tasking/tst_tasking.cpp @@ -265,10 +265,10 @@ void tst_Tasking::testTree_data() return [=] { storage->m_log.append({taskId, Handler::Sync}); return success; }; }; - const auto constructSimpleSequence = [=](const Workflow &policy) { + const auto constructSimpleSequence = [=](WorkflowPolicy policy) { return Group { Storage(storage), - policy, + workflowPolicy(policy), Test(setupTask(1), logDone), Test(setupFailingTask(2), logDone, logError), Test(setupTask(3), logDone), @@ -632,7 +632,7 @@ void tst_Tasking::testTree_data() } { - const Group root = constructSimpleSequence(stopOnError); + const Group root = constructSimpleSequence(WorkflowPolicy::StopOnError); const Log log { {1, Handler::Setup}, {1, Handler::Done}, @@ -644,7 +644,7 @@ void tst_Tasking::testTree_data() } { - const Group root = constructSimpleSequence(continueOnError); + const Group root = constructSimpleSequence(WorkflowPolicy::ContinueOnError); const Log log { {1, Handler::Setup}, {1, Handler::Done}, @@ -658,7 +658,7 @@ void tst_Tasking::testTree_data() } { - const Group root = constructSimpleSequence(stopOnDone); + const Group root = constructSimpleSequence(WorkflowPolicy::StopOnDone); const Log log { {1, Handler::Setup}, {1, Handler::Done}, @@ -668,7 +668,7 @@ void tst_Tasking::testTree_data() } { - const Group root = constructSimpleSequence(continueOnDone); + const Group root = constructSimpleSequence(WorkflowPolicy::ContinueOnDone); const Log log { {1, Handler::Setup}, {1, Handler::Done}, @@ -682,7 +682,7 @@ void tst_Tasking::testTree_data() } { - const Group root = constructSimpleSequence(stopOnFinished); + const Group root = constructSimpleSequence(WorkflowPolicy::StopOnFinished); const Log log { {1, Handler::Setup}, {1, Handler::Done}, @@ -787,7 +787,7 @@ void tst_Tasking::testTree_data() { const Group root { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { onGroupSetup(groupSetup(1)), @@ -821,7 +821,7 @@ void tst_Tasking::testTree_data() { const Group root { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { onGroupSetup(groupSetup(1)), @@ -861,7 +861,7 @@ void tst_Tasking::testTree_data() { const Group root1 { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { onGroupSetup(groupSetup(1)), @@ -890,7 +890,7 @@ void tst_Tasking::testTree_data() // - task 1 should be stopped as a consequence of the error inside the group // - tasks 4 and 5 should be skipped const Group root2 { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { onGroupSetup(groupSetup(1)), @@ -926,7 +926,7 @@ void tst_Tasking::testTree_data() continueOnError, Storage(storage), Group { - ParallelLimit(2), + parallelLimit(2), Group { onGroupSetup(groupSetup(1)), Test(setupSleepingTask(1, true, 20ms)) @@ -968,7 +968,7 @@ void tst_Tasking::testTree_data() { const Group root { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { Storage(TreeStorage()), @@ -1018,7 +1018,7 @@ void tst_Tasking::testTree_data() { const Group root { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { Storage(TreeStorage()), @@ -1064,7 +1064,7 @@ void tst_Tasking::testTree_data() { const Group root { - ParallelLimit(2), + parallelLimit(2), Storage(storage), Group { Storage(TreeStorage()), @@ -1278,7 +1278,7 @@ void tst_Tasking::testTree_data() // as in SEQUENTIAL mode the next task may only be started after the previous one finished. // In this case, the previous task (Group element) awaits for the barrier's advance to // come from the not yet started next task, causing a deadlock. - // The minimal requirement for this scenario to succeed is to set ParallelLimit(2) or more. + // The minimal requirement for this scenario to succeed is to set parallelLimit(2) or more. const Group root3 { Storage(storage), Storage(barrier), @@ -1434,7 +1434,7 @@ void tst_Tasking::testTree_data() // as in SEQUENTIAL mode the next task may only be started after the previous one finished. // In this case, the previous task (Group element) awaits for the barrier's advance to // come from the not yet started next task, causing a deadlock. - // The minimal requirement for this scenario to succeed is to set ParallelLimit(2) or more. + // The minimal requirement for this scenario to succeed is to set parallelLimit(2) or more. const Group root3 { Storage(storage), Storage(barrier), diff --git a/tests/manual/tasktree/main.cpp b/tests/manual/tasktree/main.cpp index de575346bf8..ac5df4b0f6c 100644 --- a/tests/manual/tasktree/main.cpp +++ b/tests/manual/tasktree/main.cpp @@ -171,14 +171,14 @@ int main(int argc, char *argv[]) const Group root { rootGroup->executeMode(), - Workflow(rootGroup->workflowPolicy()), + workflowPolicy(rootGroup->workflowPolicy()), onGroupSetup([rootGroup] { rootGroup->setState(State::Running); }), onGroupDone([rootGroup] { rootGroup->setState(State::Done); }), onGroupError([rootGroup] { rootGroup->setState(State::Error); }), Group { groupTask_1->executeMode(), - Workflow(groupTask_1->workflowPolicy()), + workflowPolicy(groupTask_1->workflowPolicy()), onGroupSetup([groupTask_1] { groupTask_1->setState(State::Running); }), onGroupDone([groupTask_1] { groupTask_1->setState(State::Done); }), onGroupError([groupTask_1] { groupTask_1->setState(State::Error); }), @@ -191,7 +191,7 @@ int main(int argc, char *argv[]) taskItem(task_3), Group { groupTask_4->executeMode(), - Workflow(groupTask_4->workflowPolicy()), + workflowPolicy(groupTask_4->workflowPolicy()), onGroupSetup([groupTask_4] { groupTask_4->setState(State::Running); }), onGroupDone([groupTask_4] { groupTask_4->setState(State::Done); }), onGroupError([groupTask_4] { groupTask_4->setState(State::Error); }), @@ -200,7 +200,7 @@ int main(int argc, char *argv[]) taskItem(task_4_2), Group { groupTask_4_3->executeMode(), - Workflow(groupTask_4_3->workflowPolicy()), + workflowPolicy(groupTask_4_3->workflowPolicy()), onGroupSetup([groupTask_4_3] { groupTask_4_3->setState(State::Running); }), onGroupDone([groupTask_4_3] { groupTask_4_3->setState(State::Done); }), onGroupError([groupTask_4_3] { groupTask_4_3->setState(State::Error); }), diff --git a/tests/manual/tasktree/taskwidget.cpp b/tests/manual/tasktree/taskwidget.cpp index 0f721641813..e969dbf2d73 100644 --- a/tests/manual/tasktree/taskwidget.cpp +++ b/tests/manual/tasktree/taskwidget.cpp @@ -165,7 +165,7 @@ void GroupWidget::updateExecuteMode() m_executeCombo->setCurrentIndex(m_executeCombo->findData((int)m_executeMode)); } -Tasking::ParallelLimit GroupWidget::executeMode() const +Tasking::TaskItem GroupWidget::executeMode() const { return m_executeMode == ExecuteMode::Sequential ? Tasking::sequential : Tasking::parallel; } diff --git a/tests/manual/tasktree/taskwidget.h b/tests/manual/tasktree/taskwidget.h index dc8821af5e1..c425f23965f 100644 --- a/tests/manual/tasktree/taskwidget.h +++ b/tests/manual/tasktree/taskwidget.h @@ -61,7 +61,7 @@ public: GroupWidget(); void setExecuteMode(ExecuteMode mode); - Tasking::ParallelLimit executeMode() const; + Tasking::TaskItem executeMode() const; void setWorkflowPolicy(Tasking::WorkflowPolicy policy); Tasking::WorkflowPolicy workflowPolicy() const;