diff --git a/src/libs/solutions/tasking/barrier.h b/src/libs/solutions/tasking/barrier.h index 6f1afe39b09..705ddd5f5b7 100644 --- a/src/libs/solutions/tasking/barrier.h +++ b/src/libs/solutions/tasking/barrier.h @@ -83,14 +83,14 @@ public: "It is possible that no barrier was added to the tree, " "or the storage is not reachable from where it is referenced. " "The WaitForBarrier task will finish with error. "); - return TaskAction::StopWithError; + return SetupResult::StopWithError; } Barrier *activeSharedBarrier = activeBarrier->barrier(); const std::optional result = activeSharedBarrier->result(); if (result.has_value()) - return result.value() ? TaskAction::StopWithDone : TaskAction::StopWithError; + return result.value() ? SetupResult::StopWithDone : SetupResult::StopWithError; QObject::connect(activeSharedBarrier, &Barrier::done, &barrier, &Barrier::stopWithResult); - return TaskAction::Continue; + return SetupResult::Continue; }) {} }; diff --git a/src/libs/solutions/tasking/tasktree.cpp b/src/libs/solutions/tasking/tasktree.cpp index 83b586deef5..832267cca45 100644 --- a/src/libs/solutions/tasking/tasktree.cpp +++ b/src/libs/solutions/tasking/tasktree.cpp @@ -236,7 +236,7 @@ private: */ /*! - \enum Tasking::TaskAction + \enum Tasking::SetupResult This enum is optionally returned from the group's or task's setup handler function. It instructs the running task tree on how to proceed after the setup handler's execution @@ -264,21 +264,21 @@ private: /*! \typealias GroupItem::GroupSetupHandler - Type alias for \c std::function. + Type alias for \c std::function. The GroupSetupHandler is used when constructing the onGroupSetup() element. Any function with the above signature, when passed as a group setup handler, will be called by the running task tree when the group execution starts. The return value of the handler instructs the running group on how to proceed - after the handler's invocation is finished. The default return value of TaskAction::Continue + after the handler's invocation is finished. The default return value of SetupResult::Continue instructs the group to continue running, i.e. to start executing its child tasks. - The return value of TaskAction::StopWithDone or TaskAction::StopWithError + The return value of SetupResult::StopWithDone or SetupResult::StopWithError instructs the group to skip the child tasks' execution and finish immediately with success or an error, respectively. - When the return type is either TaskAction::StopWithDone - of TaskAction::StopWithError, the group's done or error handler (if provided) + When the return type is either SetupResult::StopWithDone + of SetupResult::StopWithError, the group's done or error handler (if provided) is called synchronously immediately afterwards. \note Even if the group setup handler returns StopWithDone or StopWithError, @@ -287,7 +287,7 @@ private: The onGroupSetup() accepts also functions in the shortened form of \c std::function, i.e. the return value is void. In this case it's assumed that the return value - is TaskAction::Continue by default. + is SetupResult::Continue by default. \sa onGroupSetup() */ @@ -311,7 +311,7 @@ private: Constructs a group's element holding the group setup handler. The \a handler is invoked whenever the group starts. - The passed \a handler is either of \c std::function or \c std::function + The passed \a handler is either of \c std::function or \c std::function type. For more information on possible argument type, refer to \l {GroupItem::GroupSetupHandler}. @@ -432,9 +432,9 @@ const GroupItem stopOnFinished = workflowPolicy(WorkflowPolicy::StopOnFinished); const GroupItem finishAllAndDone = workflowPolicy(WorkflowPolicy::FinishAllAndDone); const GroupItem finishAllAndError = workflowPolicy(WorkflowPolicy::FinishAllAndError); -static TaskAction toTaskAction(bool success) +static SetupResult toSetupResult(bool success) { - return success ? TaskAction::StopWithDone : TaskAction::StopWithError; + return success ? SetupResult::StopWithDone : SetupResult::StopWithError; } bool TreeStorageBase::isValid() const @@ -660,10 +660,10 @@ public: TaskContainer(TaskTreePrivate *taskTreePrivate, const GroupItem &task, TaskNode *parentNode, TaskContainer *parentContainer) : m_constData(taskTreePrivate, task, parentNode, parentContainer, this) {} - TaskAction start(); - TaskAction continueStart(TaskAction startAction, int nextChild); - TaskAction startChildren(int nextChild); - TaskAction childDone(bool success); + SetupResult start(); + SetupResult continueStart(SetupResult startAction, int nextChild); + SetupResult startChildren(int nextChild); + SetupResult childDone(bool success); void stop(); void invokeEndHandler(); bool isRunning() const { return m_runtimeData.has_value(); } @@ -718,7 +718,7 @@ public: // If returned value != Continue, childDone() needs to be called in parent container (in caller) // in order to unwind properly. - TaskAction start(); + SetupResult start(); void stop(); void invokeEndHandler(bool success); bool isRunning() const { return m_task || m_container.isRunning(); } @@ -947,34 +947,34 @@ int TaskContainer::RuntimeData::currentLimit() const ? qMin(m_doneCount + m_constData.m_parallelLimit, childCount) : childCount; } -TaskAction TaskContainer::start() +SetupResult TaskContainer::start() { QTC_CHECK(!isRunning()); m_runtimeData.emplace(m_constData); - TaskAction startAction = TaskAction::Continue; + SetupResult startAction = SetupResult::Continue; if (m_constData.m_groupHandler.m_setupHandler) { startAction = invokeHandler(this, m_constData.m_groupHandler.m_setupHandler); - if (startAction != TaskAction::Continue) { + if (startAction != SetupResult::Continue) { m_constData.m_taskTreePrivate->advanceProgress(m_constData.m_taskCount); - // Non-Continue TaskAction takes precedence over the workflow policy. - m_runtimeData->m_successBit = startAction == TaskAction::StopWithDone; + // Non-Continue SetupResult takes precedence over the workflow policy. + m_runtimeData->m_successBit = startAction == SetupResult::StopWithDone; } } - if (startAction == TaskAction::Continue) { + if (startAction == SetupResult::Continue) { if (m_constData.m_children.isEmpty()) - startAction = toTaskAction(m_runtimeData->m_successBit); + startAction = toSetupResult(m_runtimeData->m_successBit); } return continueStart(startAction, 0); } -TaskAction TaskContainer::continueStart(TaskAction startAction, int nextChild) +SetupResult TaskContainer::continueStart(SetupResult startAction, int nextChild) { - const TaskAction groupAction = startAction == TaskAction::Continue ? startChildren(nextChild) + const SetupResult groupAction = startAction == SetupResult::Continue ? startChildren(nextChild) : startAction; QTC_CHECK(isRunning()); // TODO: superfluous - if (groupAction != TaskAction::Continue) { - const bool success = m_runtimeData->updateSuccessBit(groupAction == TaskAction::StopWithDone); + if (groupAction != SetupResult::Continue) { + const bool success = m_runtimeData->updateSuccessBit(groupAction == SetupResult::StopWithDone); invokeEndHandler(); if (TaskContainer *parentContainer = m_constData.m_parentContainer) { QTC_CHECK(parentContainer->isRunning()); @@ -989,7 +989,7 @@ TaskAction TaskContainer::continueStart(TaskAction startAction, int nextChild) return groupAction; } -TaskAction TaskContainer::startChildren(int nextChild) +SetupResult TaskContainer::startChildren(int nextChild) { QTC_CHECK(isRunning()); GuardLocker locker(m_runtimeData->m_startGuard); @@ -998,12 +998,12 @@ TaskAction TaskContainer::startChildren(int nextChild) if (i >= limit) break; - const TaskAction startAction = m_constData.m_children.at(i)->start(); - if (startAction == TaskAction::Continue) + const SetupResult startAction = m_constData.m_children.at(i)->start(); + if (startAction == SetupResult::Continue) continue; - const TaskAction finalizeAction = childDone(startAction == TaskAction::StopWithDone); - if (finalizeAction == TaskAction::Continue) + const SetupResult finalizeAction = childDone(startAction == SetupResult::StopWithDone); + if (finalizeAction == SetupResult::Continue) continue; int skippedTaskCount = 0; @@ -1013,10 +1013,10 @@ TaskAction TaskContainer::startChildren(int nextChild) m_constData.m_taskTreePrivate->advanceProgress(skippedTaskCount); return finalizeAction; } - return TaskAction::Continue; + return SetupResult::Continue; } -TaskAction TaskContainer::childDone(bool success) +SetupResult TaskContainer::childDone(bool success) { QTC_CHECK(isRunning()); const int limit = m_runtimeData->currentLimit(); // Read before bumping m_doneCount and stop() @@ -1028,9 +1028,9 @@ TaskAction TaskContainer::childDone(bool success) ++m_runtimeData->m_doneCount; const bool updatedSuccess = m_runtimeData->updateSuccessBit(success); - const TaskAction startAction + const SetupResult startAction = (shouldStop || m_runtimeData->m_doneCount == m_constData.m_children.size()) - ? toTaskAction(updatedSuccess) : TaskAction::Continue; + ? toSetupResult(updatedSuccess) : SetupResult::Continue; if (isStarting()) return startAction; @@ -1064,30 +1064,30 @@ void TaskContainer::invokeEndHandler() m_runtimeData.reset(); } -TaskAction TaskNode::start() +SetupResult TaskNode::start() { QTC_CHECK(!isRunning()); if (!isTask()) return m_container.start(); m_task.reset(m_taskHandler.m_createHandler()); - const TaskAction startAction = m_taskHandler.m_setupHandler + const SetupResult startAction = m_taskHandler.m_setupHandler ? invokeHandler(parentContainer(), m_taskHandler.m_setupHandler, *m_task.get()) - : TaskAction::Continue; - if (startAction != TaskAction::Continue) { + : SetupResult::Continue; + if (startAction != SetupResult::Continue) { m_container.m_constData.m_taskTreePrivate->advanceProgress(1); m_task.reset(); return startAction; } - const std::shared_ptr unwindAction - = std::make_shared(TaskAction::Continue); + const std::shared_ptr unwindAction + = std::make_shared(SetupResult::Continue); QObject::connect(m_task.get(), &TaskInterface::done, taskTree(), [=](bool success) { invokeEndHandler(success); QObject::disconnect(m_task.get(), &TaskInterface::done, taskTree(), nullptr); m_task.release()->deleteLater(); QTC_ASSERT(parentContainer() && parentContainer()->isRunning(), return); if (parentContainer()->isStarting()) - *unwindAction = toTaskAction(success); + *unwindAction = toSetupResult(success); else parentContainer()->childDone(success); }); @@ -1326,18 +1326,18 @@ void TaskNode::invokeEndHandler(bool success) as the task tree calls it when needed. The setup handler is optional. When used, it must be the first argument of the task's constructor. - Optionally, the setup handler may return a TaskAction. The returned - TaskAction influences the further start behavior of a given task. The + Optionally, the setup handler may return a SetupResult. The returned + SetupResult influences the further start behavior of a given task. The possible values are: \table \header - \li TaskAction Value + \li SetupResult Value \li Brief Description \row \li Continue \li The task will be started normally. This is the default behavior when the - setup handler doesn't return TaskAction (that is, its return type is + setup handler doesn't return SetupResult (that is, its return type is void). \row \li StopWithDone @@ -1409,12 +1409,12 @@ void TaskNode::invokeEndHandler(bool success) handler. If you add more than one onGroupSetup() element to a group, an assert is triggered at runtime that includes an error message. - Like the task's start handler, the group start handler may return TaskAction. - The returned TaskAction value affects the start behavior of the + Like the task's start handler, the group start handler may return SetupResult. + The returned SetupResult value affects the start behavior of the whole group. If you do not specify a group start handler or its return type - is void, the default group's action is TaskAction::Continue, so that all + is void, the default group's action is SetupResult::Continue, so that all tasks are started normally. Otherwise, when the start handler returns - TaskAction::StopWithDone or TaskAction::StopWithError, the tasks are not + SetupResult::StopWithDone or SetupResult::StopWithError, the tasks are not started (they are skipped) and the group itself reports success or failure, depending on the returned value, respectively. @@ -1422,15 +1422,15 @@ void TaskNode::invokeEndHandler(bool success) const Group root { onGroupSetup([] { qDebug() << "Root setup"; }), Group { - onGroupSetup([] { qDebug() << "Group 1 setup"; return TaskAction::Continue; }), + onGroupSetup([] { qDebug() << "Group 1 setup"; return SetupResult::Continue; }), ProcessTask(...) // Process 1 }, Group { - onGroupSetup([] { qDebug() << "Group 2 setup"; return TaskAction::StopWithDone; }), + onGroupSetup([] { qDebug() << "Group 2 setup"; return SetupResult::StopWithDone; }), ProcessTask(...) // Process 2 }, Group { - onGroupSetup([] { qDebug() << "Group 3 setup"; return TaskAction::StopWithError; }), + onGroupSetup([] { qDebug() << "Group 3 setup"; return SetupResult::StopWithError; }), ProcessTask(...) // Process 3 }, ProcessTask(...) // Process 4 @@ -1446,7 +1446,7 @@ void TaskNode::invokeEndHandler(bool success) \li Comment \row \li Root Group starts - \li Doesn't return TaskAction, so its tasks are executed. + \li Doesn't return SetupResult, so its tasks are executed. \row \li Group 1 starts \li Returns Continue, so its tasks are executed. @@ -1838,7 +1838,7 @@ void TaskTree::setRecipe(const Group &recipe) Otherwise, the task tree is started. The started task tree may finish synchronously, - for example when the main group's start handler returns TaskAction::StopWithError. + for example when the main group's start handler returns SetupResult::StopWithError. For this reason, the connections to the done and errorOccurred signals should be established before calling start. Use isRunning() in order to detect whether the task tree is still running after a call to start(). diff --git a/src/libs/solutions/tasking/tasktree.h b/src/libs/solutions/tasking/tasktree.h index 11cc2708dd4..82fafd77bb6 100644 --- a/src/libs/solutions/tasking/tasktree.h +++ b/src/libs/solutions/tasking/tasktree.h @@ -115,13 +115,13 @@ enum class WorkflowPolicy { }; Q_ENUM_NS(WorkflowPolicy); -enum class TaskAction +enum class SetupResult { Continue, StopWithDone, StopWithError }; -Q_ENUM_NS(TaskAction); +Q_ENUM_NS(SetupResult); class TASKING_EXPORT GroupItem { @@ -129,11 +129,11 @@ public: // Internal, provided by QTC_DECLARE_CUSTOM_TASK using TaskCreateHandler = std::function; // Called prior to task start, just after createHandler - using TaskSetupHandler = std::function; + using TaskSetupHandler = std::function; // Called on task done / error using TaskEndHandler = std::function; // Called when group entered - using GroupSetupHandler = std::function; + using GroupSetupHandler = std::function; // Called when group done / error using GroupEndHandler = std::function; @@ -228,17 +228,17 @@ private: static GroupSetupHandler wrapGroupSetup(SetupHandler &&handler) { static constexpr bool isDynamic - = std::is_same_v>>; + = std::is_same_v>>; constexpr bool isVoid = std::is_same_v>>; static_assert(isDynamic || isVoid, "Group setup handler needs to take no arguments and has to return " - "void or TaskAction. The passed handler doesn't fulfill these requirements."); + "void or SetupResult. The passed handler doesn't fulfill these requirements."); return [=] { if constexpr (isDynamic) return std::invoke(handler); std::invoke(handler); - return TaskAction::Continue; + return SetupResult::Continue; }; }; }; @@ -290,10 +290,10 @@ private: static_assert(isBool || isVoid, "Sync element: The synchronous function has to return void or bool."); if constexpr (isBool) { - return {onGroupSetup([function] { return function() ? TaskAction::StopWithDone - : TaskAction::StopWithError; })}; + return {onGroupSetup([function] { return function() ? SetupResult::StopWithDone + : SetupResult::StopWithError; })}; } - return {onGroupSetup([function] { function(); return TaskAction::StopWithDone; })}; + return {onGroupSetup([function] { function(); return SetupResult::StopWithDone; })}; }; }; @@ -344,19 +344,19 @@ public: private: template static GroupItem::TaskSetupHandler wrapSetup(SetupFunction &&function) { - static constexpr bool isDynamic = std::is_same_v, typename Adapter::Type &>>; constexpr bool isVoid = std::is_same_v, typename Adapter::Type &>>; static_assert(isDynamic || isVoid, "Task setup handler needs to take (Task &) as an argument and has to return " - "void or TaskAction. The passed handler doesn't fulfill these requirements."); + "void or SetupResult. The passed handler doesn't fulfill these requirements."); return [=](TaskInterface &taskInterface) { Adapter &adapter = static_cast(taskInterface); if constexpr (isDynamic) return std::invoke(function, *adapter.task()); std::invoke(function, *adapter.task()); - return TaskAction::Continue; + return SetupResult::Continue; }; }; diff --git a/src/plugins/autotest/testrunner.cpp b/src/plugins/autotest/testrunner.cpp index b2670b6d555..d355317b5eb 100644 --- a/src/plugins/autotest/testrunner.cpp +++ b/src/plugins/autotest/testrunner.cpp @@ -355,13 +355,13 @@ void TestRunner::runTestsHelper() const auto onSetup = [this, config] { if (!config->project()) - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; if (config->testExecutable().isEmpty()) { reportResult(ResultType::MessageFatal, Tr::tr("Executable path is empty. (%1)").arg(config->displayName())); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onProcessSetup = [this, config, storage](Process &process) { TestStorage *testStorage = storage.activeStorage(); diff --git a/src/plugins/boot2qt/qdbstopapplicationstep.cpp b/src/plugins/boot2qt/qdbstopapplicationstep.cpp index 5fef60268f9..1949aac9580 100644 --- a/src/plugins/boot2qt/qdbstopapplicationstep.cpp +++ b/src/plugins/boot2qt/qdbstopapplicationstep.cpp @@ -43,7 +43,7 @@ Group QdbStopApplicationStep::deployRecipe() const auto device = DeviceKitAspect::device(target()->kit()); if (!device) { addErrorMessage(Tr::tr("No device to stop the application on.")); - return TaskAction::StopWithError; + return SetupResult::StopWithError; } QTC_CHECK(device); process.setCommand({device->filePath(Constants::AppcontrollerFilepath), {"--stop"}}); @@ -52,7 +52,7 @@ Group QdbStopApplicationStep::deployRecipe() connect(proc, &Process::readyReadStandardOutput, this, [this, proc] { handleStdOutData(proc->readAllStandardOutput()); }); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto doneHandler = [this](const Process &) { addProgressMessage(Tr::tr("Stopped the running application.")); diff --git a/src/plugins/clangtools/clangtoolrunner.cpp b/src/plugins/clangtools/clangtoolrunner.cpp index bfbc9b3957f..666f07963b2 100644 --- a/src/plugins/clangtools/clangtoolrunner.cpp +++ b/src/plugins/clangtools/clangtoolrunner.cpp @@ -128,23 +128,23 @@ GroupItem clangToolTask(const AnalyzeInputData &input, const auto onSetup = [=] { if (setupHandler && !setupHandler()) - return TaskAction::StopWithError; + return SetupResult::StopWithError; ClangToolStorage *data = storage.activeStorage(); data->name = clangToolName(input.tool); data->executable = toolExecutable(input.tool); if (!data->executable.isExecutableFile()) { qWarning() << "Can't start:" << data->executable << "as" << data->name; - return TaskAction::StopWithError; + return SetupResult::StopWithError; } QTC_CHECK(!input.unit.arguments.contains(QLatin1String("-o"))); QTC_CHECK(!input.unit.arguments.contains(input.unit.file.nativePath())); - QTC_ASSERT(input.unit.file.exists(), return TaskAction::StopWithError); + QTC_ASSERT(input.unit.file.exists(), return SetupResult::StopWithError); data->outputFilePath = createOutputFilePath(input.outputDirPath, input.unit.file); - QTC_ASSERT(!data->outputFilePath.isEmpty(), return TaskAction::StopWithError); + QTC_ASSERT(!data->outputFilePath.isEmpty(), return SetupResult::StopWithError); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onProcessSetup = [=](Process &process) { process.setEnvironment(input.environment); diff --git a/src/plugins/coreplugin/actionsfilter.cpp b/src/plugins/coreplugin/actionsfilter.cpp index 01772ac2520..3b805f76f72 100644 --- a/src/plugins/coreplugin/actionsfilter.cpp +++ b/src/plugins/coreplugin/actionsfilter.cpp @@ -190,11 +190,11 @@ LocatorMatcherTasks ActionsFilter::matchers() collectEntriesForCommands(); if (storage->input().simplified().isEmpty()) { storage->reportOutput(m_entries); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } async.setFutureSynchronizer(ExtensionSystem::PluginManager::futureSynchronizer()); async.setConcurrentCallData(matches, *storage, m_entries); - return TaskAction::Continue; + return SetupResult::Continue; }; return {{AsyncTask(onSetup), storage}}; diff --git a/src/plugins/coreplugin/locator/directoryfilter.cpp b/src/plugins/coreplugin/locator/directoryfilter.cpp index 42cf51addf7..6acdb74720a 100644 --- a/src/plugins/coreplugin/locator/directoryfilter.cpp +++ b/src/plugins/coreplugin/locator/directoryfilter.cpp @@ -82,9 +82,9 @@ DirectoryFilter::DirectoryFilter(Id id) using namespace Tasking; const auto groupSetup = [this] { if (!m_directories.isEmpty()) - return TaskAction::Continue; // Async task will run + return SetupResult::Continue; // Async task will run m_cache.setFilePaths({}); - return TaskAction::StopWithDone; // Group stops, skips async task + return SetupResult::StopWithDone; // Group stops, skips async task }; const auto asyncSetup = [this](Async &async) { async.setConcurrentCallData(&refresh, m_directories, m_filters, m_exclusionFilters, diff --git a/src/plugins/coreplugin/locator/ilocatorfilter.cpp b/src/plugins/coreplugin/locator/ilocatorfilter.cpp index 74ad227e977..7f272fd108d 100644 --- a/src/plugins/coreplugin/locator/ilocatorfilter.cpp +++ b/src/plugins/coreplugin/locator/ilocatorfilter.cpp @@ -1503,16 +1503,16 @@ LocatorMatcherTask LocatorFileCache::matcher() const const auto onSetup = [storage, weak](Async &async) { auto that = weak.lock(); if (!that) // LocatorMatcher is running after *this LocatorFileCache was destructed. - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; if (!that->ensureValidated()) - return TaskAction::StopWithDone; // The cache is invalid and + return SetupResult::StopWithDone; // The cache is invalid and // no provider is set or it returned empty generator that->bumpExecutionId(); async.setFutureSynchronizer(ExtensionSystem::PluginManager::futureSynchronizer()); async.setConcurrentCallData(&filter, *storage, *that); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onDone = [weak](const Async &async) { auto that = weak.lock(); diff --git a/src/plugins/coreplugin/locator/javascriptfilter.cpp b/src/plugins/coreplugin/locator/javascriptfilter.cpp index b179b32316d..a15cabd8d9d 100644 --- a/src/plugins/coreplugin/locator/javascriptfilter.cpp +++ b/src/plugins/coreplugin/locator/javascriptfilter.cpp @@ -372,7 +372,7 @@ LocatorMatcherTasks JavaScriptFilter::matchers() const auto onSetup = [storage, engine] { if (!engine) - return TaskAction::StopWithError; + return SetupResult::StopWithError; if (storage->input().trimmed().isEmpty()) { LocatorFilterEntry entry; entry.displayName = Tr::tr("Reset Engine"); @@ -385,9 +385,9 @@ LocatorMatcherTasks JavaScriptFilter::matchers() return AcceptResult(); }; storage->reportOutput({entry}); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onJavaScriptSetup = [storage, engine](JavaScriptRequest &request) { diff --git a/src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp b/src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp index 64ea71998b7..d89bec2263b 100644 --- a/src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp +++ b/src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp @@ -179,7 +179,7 @@ LocatorMatcherTasks SpotlightLocatorFilter::matchers() const Link link = Link::fromString(storage->input(), true); const FilePath input = link.targetFilePath; if (input.isEmpty()) - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; // only pass the file name part to allow searches like "somepath/*foo" const std::unique_ptr expander(createMacroExpander(input.fileName())); @@ -189,7 +189,7 @@ LocatorMatcherTasks SpotlightLocatorFilter::matchers() CommandLine::Raw); async.setFutureSynchronizer(ExtensionSystem::PluginManager::futureSynchronizer()); async.setConcurrentCallData(matches, *storage, cmd); - return TaskAction::Continue; + return SetupResult::Continue; }; return {{AsyncTask(onSetup), storage}}; diff --git a/src/plugins/git/gitclient.cpp b/src/plugins/git/gitclient.cpp index 90f002e0994..70954ff4214 100644 --- a/src/plugins/git/gitclient.cpp +++ b/src/plugins/git/gitclient.cpp @@ -310,12 +310,12 @@ FileListDiffController::FileListDiffController(IDocument *document, const QStrin const auto setupStaged = [this, stagedFiles](Process &process) { if (stagedFiles.isEmpty()) - return TaskAction::StopWithError; + return SetupResult::StopWithError; process.setCodec(VcsBaseEditor::getCodec(workingDirectory(), stagedFiles)); setupCommand(process, addConfigurationArguments( QStringList({"diff", "--cached", "--"}) + stagedFiles)); VcsOutputWindow::appendCommand(process.workingDirectory(), process.commandLine()); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onStagedDone = [storage](const Process &process) { storage->m_stagedOutput = process.cleanedStdOut(); @@ -323,12 +323,12 @@ FileListDiffController::FileListDiffController(IDocument *document, const QStrin const auto setupUnstaged = [this, unstagedFiles](Process &process) { if (unstagedFiles.isEmpty()) - return TaskAction::StopWithError; + return SetupResult::StopWithError; process.setCodec(VcsBaseEditor::getCodec(workingDirectory(), unstagedFiles)); setupCommand(process, addConfigurationArguments( QStringList({"diff", "--"}) + unstagedFiles)); VcsOutputWindow::appendCommand(process.workingDirectory(), process.commandLine()); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onUnstagedDone = [storage](const Process &process) { storage->m_unstagedOutput = process.cleanedStdOut(); @@ -421,8 +421,8 @@ ShowController::ShowController(IDocument *document, const QString &id) const auto desciptionDetailsSetup = [storage] { if (!storage->m_postProcessDescription) - return TaskAction::StopWithDone; - return TaskAction::Continue; + return SetupResult::StopWithDone; + return SetupResult::Continue; }; const auto setupBranches = [this, storage](Process &process) { diff --git a/src/plugins/languageclient/locatorfilter.cpp b/src/plugins/languageclient/locatorfilter.cpp index da03b2e7c50..61a6d187daa 100644 --- a/src/plugins/languageclient/locatorfilter.cpp +++ b/src/plugins/languageclient/locatorfilter.cpp @@ -69,10 +69,10 @@ LocatorMatcherTask locatorMatcher(Client *client, int maxResultCount, const auto onFilterSetup = [storage, resultStorage, client, filter](Async &async) { const QList results = *resultStorage; if (results.isEmpty()) - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; async.setFutureSynchronizer(ExtensionSystem::PluginManager::futureSynchronizer()); async.setConcurrentCallData(filterResults, *storage, client, results, filter); - return TaskAction::Continue; + return SetupResult::Continue; }; const Group root { diff --git a/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp b/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp index 856f8740a62..5855352975c 100644 --- a/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp +++ b/src/plugins/qnx/qnxdeployqtlibrariesdialog.cpp @@ -149,10 +149,10 @@ GroupItem QnxDeployQtLibrariesDialogPrivate::removeDirTask() { const auto setupHandler = [this](Process &process) { if (m_checkResult != CheckResult::RemoveDir) - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; m_deployLogWindow->appendPlainText(Tr::tr("Removing \"%1\"").arg(fullRemoteDirectory())); process.setCommand({m_device->filePath("rm"), {"-rf", fullRemoteDirectory()}}); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto errorHandler = [this](const Process &process) { QTC_ASSERT(process.exitCode() == 0, return); @@ -167,7 +167,7 @@ GroupItem QnxDeployQtLibrariesDialogPrivate::uploadTask() const auto setupHandler = [this](FileTransfer &transfer) { if (m_deployableFiles.isEmpty()) { emitProgressMessage(Tr::tr("No files need to be uploaded.")); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } emitProgressMessage(Tr::tr("%n file(s) need to be uploaded.", "", m_deployableFiles.size())); @@ -177,18 +177,18 @@ GroupItem QnxDeployQtLibrariesDialogPrivate::uploadTask() const QString message = Tr::tr("Local file \"%1\" does not exist.") .arg(file.localFilePath().toUserOutput()); emitErrorMessage(message); - return TaskAction::StopWithError; + return SetupResult::StopWithError; } files.append({file.localFilePath(), m_device->filePath(file.remoteFilePath())}); } if (files.isEmpty()) { emitProgressMessage(Tr::tr("No files need to be uploaded.")); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } transfer.setFilesToTransfer(files); QObject::connect(&transfer, &FileTransfer::progress, this, &QnxDeployQtLibrariesDialogPrivate::emitProgressMessage); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto errorHandler = [this](const FileTransfer &transfer) { emitErrorMessage(transfer.resultData().m_errorString); @@ -238,7 +238,7 @@ Group QnxDeployQtLibrariesDialogPrivate::deployRecipe() const auto setupHandler = [this] { if (!m_device) { emitErrorMessage(Tr::tr("No device configuration set.")); - return TaskAction::StopWithError; + return SetupResult::StopWithError; } QList collected; for (int i = 0; i < m_deployableFiles.count(); ++i) @@ -247,18 +247,18 @@ Group QnxDeployQtLibrariesDialogPrivate::deployRecipe() QTC_CHECK(collected.size() >= m_deployableFiles.size()); m_deployableFiles = collected; if (!m_deployableFiles.isEmpty()) - return TaskAction::Continue; + return SetupResult::Continue; emitProgressMessage(Tr::tr("No deployment action necessary. Skipping.")); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; }; const auto doneHandler = [this] { emitProgressMessage(Tr::tr("All files successfully deployed.")); }; const auto subGroupSetupHandler = [this] { if (m_checkResult == CheckResult::Abort) - return TaskAction::StopWithError; - return TaskAction::Continue; + return SetupResult::StopWithError; + return SetupResult::Continue; }; const Group root { onGroupSetup(setupHandler), diff --git a/src/plugins/remotelinux/genericdirectuploadstep.cpp b/src/plugins/remotelinux/genericdirectuploadstep.cpp index 4449284ea64..62dd58467ed 100644 --- a/src/plugins/remotelinux/genericdirectuploadstep.cpp +++ b/src/plugins/remotelinux/genericdirectuploadstep.cpp @@ -194,7 +194,7 @@ GroupItem GenericDirectUploadStep::uploadTask(const TreeStorage & const auto setupHandler = [this, storage](FileTransfer &transfer) { if (storage->filesToUpload.isEmpty()) { addProgressMessage(Tr::tr("No files need to be uploaded.")); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } addProgressMessage(Tr::tr("%n file(s) need to be uploaded.", "", storage->filesToUpload.size())); @@ -208,19 +208,19 @@ GroupItem GenericDirectUploadStep::uploadTask(const TreeStorage & continue; } addErrorMessage(message); - return TaskAction::StopWithError; + return SetupResult::StopWithError; } files.append({file.localFilePath(), deviceConfiguration()->filePath(file.remoteFilePath())}); } if (files.isEmpty()) { addProgressMessage(Tr::tr("No files need to be uploaded.")); - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; } transfer.setFilesToTransfer(files); QObject::connect(&transfer, &FileTransfer::progress, this, &GenericDirectUploadStep::addProgressMessage); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto errorHandler = [this](const FileTransfer &transfer) { addErrorMessage(transfer.resultData().m_errorString); diff --git a/src/plugins/subversion/subversionclient.cpp b/src/plugins/subversion/subversionclient.cpp index ac664a69b88..4ab11b6c913 100644 --- a/src/plugins/subversion/subversionclient.cpp +++ b/src/plugins/subversion/subversionclient.cpp @@ -167,13 +167,13 @@ SubversionDiffEditorController::SubversionDiffEditorController(IDocument *docume const auto setupDescription = [this](Process &process) { if (m_changeNumber == 0) - return TaskAction::StopWithDone; + return SetupResult::StopWithDone; setupCommand(process, {"log", "-r", QString::number(m_changeNumber)}); CommandLine command = process.commandLine(); command << SubversionClient::AddAuthOptions(); process.setCommand(command); setDescription(Tr::tr("Waiting for data...")); - return TaskAction::Continue; + return SetupResult::Continue; }; const auto onDescriptionDone = [this](const Process &process) { setDescription(process.cleanedStdOut()); diff --git a/tests/auto/solutions/tasking/tst_tasking.cpp b/tests/auto/solutions/tasking/tst_tasking.cpp index fabf6d5c242..5f25008228b 100644 --- a/tests/auto/solutions/tasking/tst_tasking.cpp +++ b/tests/auto/solutions/tasking/tst_tasking.cpp @@ -227,7 +227,7 @@ void tst_Tasking::testTree_data() }; }; - const auto setupDynamicTask = [storage](int taskId, TaskAction action) { + const auto setupDynamicTask = [storage](int taskId, SetupResult action) { return [storage, taskId, action](TaskObject &) { storage->m_log.append({taskId, Handler::Setup}); return action; @@ -274,7 +274,7 @@ void tst_Tasking::testTree_data() }; const auto createDynamicTask = [storage, setupDynamicTask, setupDone, setupError]( - int taskId, TaskAction action) { + int taskId, SetupResult action) { return TestTask(setupDynamicTask(taskId, action), setupDone(taskId), setupError(taskId)); }; @@ -302,19 +302,19 @@ void tst_Tasking::testTree_data() }; const Group root2 { Storage(storage), - onGroupSetup([] { return TaskAction::Continue; }), + onGroupSetup([] { return SetupResult::Continue; }), groupDone(0), groupError(0) }; const Group root3 { Storage(storage), - onGroupSetup([] { return TaskAction::StopWithDone; }), + onGroupSetup([] { return SetupResult::StopWithDone; }), groupDone(0), groupError(0) }; const Group root4 { Storage(storage), - onGroupSetup([] { return TaskAction::StopWithError; }), + onGroupSetup([] { return SetupResult::StopWithError; }), groupDone(0), groupError(0) }; @@ -329,22 +329,22 @@ void tst_Tasking::testTree_data() } { - const auto setupGroup = [=](TaskAction taskAction, WorkflowPolicy policy) { + const auto setupGroup = [=](SetupResult setupResult, WorkflowPolicy policy) { return Group { Storage(storage), workflowPolicy(policy), - onGroupSetup([taskAction] { return taskAction; }), + onGroupSetup([setupResult] { return setupResult; }), groupDone(0), groupError(0) }; }; const auto doneData = [storage, setupGroup](WorkflowPolicy policy) { - return TestData{storage, setupGroup(TaskAction::StopWithDone, policy), + return TestData{storage, setupGroup(SetupResult::StopWithDone, policy), Log{{0, Handler::GroupDone}}, 0, OnDone::Success}; }; const auto errorData = [storage, setupGroup](WorkflowPolicy policy) { - return TestData{storage, setupGroup(TaskAction::StopWithError, policy), + return TestData{storage, setupGroup(SetupResult::StopWithError, policy), Log{{0, Handler::GroupError}}, 0, OnDone::Failure}; }; @@ -368,8 +368,8 @@ void tst_Tasking::testTree_data() { const Group root { Storage(storage), - createDynamicTask(1, TaskAction::StopWithDone), - createDynamicTask(2, TaskAction::StopWithDone) + createDynamicTask(1, SetupResult::StopWithDone), + createDynamicTask(2, SetupResult::StopWithDone) }; const Log log {{1, Handler::Setup}, {2, Handler::Setup}}; QTest::newRow("DynamicTaskDone") << TestData{storage, root, log, 2, OnDone::Success}; @@ -378,8 +378,8 @@ void tst_Tasking::testTree_data() { const Group root { Storage(storage), - createDynamicTask(1, TaskAction::StopWithError), - createDynamicTask(2, TaskAction::StopWithError) + createDynamicTask(1, SetupResult::StopWithError), + createDynamicTask(2, SetupResult::StopWithError) }; const Log log {{1, Handler::Setup}}; QTest::newRow("DynamicTaskError") << TestData{storage, root, log, 2, OnDone::Failure}; @@ -388,10 +388,10 @@ void tst_Tasking::testTree_data() { const Group root { Storage(storage), - createDynamicTask(1, TaskAction::Continue), - createDynamicTask(2, TaskAction::Continue), - createDynamicTask(3, TaskAction::StopWithError), - createDynamicTask(4, TaskAction::Continue) + createDynamicTask(1, SetupResult::Continue), + createDynamicTask(2, SetupResult::Continue), + createDynamicTask(3, SetupResult::StopWithError), + createDynamicTask(4, SetupResult::Continue) }; const Log log { {1, Handler::Setup}, @@ -407,10 +407,10 @@ void tst_Tasking::testTree_data() const Group root { parallel, Storage(storage), - createDynamicTask(1, TaskAction::Continue), - createDynamicTask(2, TaskAction::Continue), - createDynamicTask(3, TaskAction::StopWithError), - createDynamicTask(4, TaskAction::Continue) + createDynamicTask(1, SetupResult::Continue), + createDynamicTask(2, SetupResult::Continue), + createDynamicTask(3, SetupResult::StopWithError), + createDynamicTask(4, SetupResult::Continue) }; const Log log { {1, Handler::Setup}, @@ -426,12 +426,12 @@ void tst_Tasking::testTree_data() const Group root { parallel, Storage(storage), - createDynamicTask(1, TaskAction::Continue), - createDynamicTask(2, TaskAction::Continue), + createDynamicTask(1, SetupResult::Continue), + createDynamicTask(2, SetupResult::Continue), Group { - createDynamicTask(3, TaskAction::StopWithError) + createDynamicTask(3, SetupResult::StopWithError) }, - createDynamicTask(4, TaskAction::Continue) + createDynamicTask(4, SetupResult::Continue) }; const Log log { {1, Handler::Setup}, @@ -447,16 +447,16 @@ void tst_Tasking::testTree_data() const Group root { parallel, Storage(storage), - createDynamicTask(1, TaskAction::Continue), - createDynamicTask(2, TaskAction::Continue), + createDynamicTask(1, SetupResult::Continue), + createDynamicTask(2, SetupResult::Continue), Group { onGroupSetup([storage] { storage->m_log.append({0, Handler::GroupSetup}); - return TaskAction::StopWithError; + return SetupResult::StopWithError; }), - createDynamicTask(3, TaskAction::Continue) + createDynamicTask(3, SetupResult::Continue) }, - createDynamicTask(4, TaskAction::Continue) + createDynamicTask(4, SetupResult::Continue) }; const Log log { {1, Handler::Setup}, @@ -1319,14 +1319,14 @@ void tst_Tasking::testTree_data() { const auto createRoot = [storage, createSuccessTask, groupDone, groupError]( - TaskAction taskAction) { + SetupResult setupResult) { return Group { Storage(storage), Group { createSuccessTask(1) }, Group { - onGroupSetup([=] { return taskAction; }), + onGroupSetup([=] { return setupResult; }), createSuccessTask(2), createSuccessTask(3), createSuccessTask(4) @@ -1336,7 +1336,7 @@ void tst_Tasking::testTree_data() }; }; - const Group root1 = createRoot(TaskAction::StopWithDone); + const Group root1 = createRoot(SetupResult::StopWithDone); const Log log1 { {1, Handler::Setup}, {1, Handler::Done}, @@ -1344,7 +1344,7 @@ void tst_Tasking::testTree_data() }; QTest::newRow("DynamicSetupDone") << TestData{storage, root1, log1, 4, OnDone::Success}; - const Group root2 = createRoot(TaskAction::StopWithError); + const Group root2 = createRoot(SetupResult::StopWithError); const Log log2 { {1, Handler::Setup}, {1, Handler::Done}, @@ -1352,7 +1352,7 @@ void tst_Tasking::testTree_data() }; QTest::newRow("DynamicSetupError") << TestData{storage, root2, log2, 4, OnDone::Failure}; - const Group root3 = createRoot(TaskAction::Continue); + const Group root3 = createRoot(SetupResult::Continue); const Log log3 { {1, Handler::Setup}, {1, Handler::Done}, @@ -1419,7 +1419,7 @@ void tst_Tasking::testTree_data() }, Group { groupSetup(3), - createDynamicTask(3, TaskAction::StopWithDone) + createDynamicTask(3, SetupResult::StopWithDone) }, Group { groupSetup(4), @@ -1463,7 +1463,7 @@ void tst_Tasking::testTree_data() }, Group { groupSetup(3), - createDynamicTask(3, TaskAction::StopWithError) + createDynamicTask(3, SetupResult::StopWithError) }, Group { groupSetup(4), @@ -1502,7 +1502,7 @@ void tst_Tasking::testTree_data() }, Group { groupSetup(3), - createDynamicTask(3, TaskAction::StopWithError) + createDynamicTask(3, SetupResult::StopWithError) }, Group { groupSetup(4), @@ -1547,7 +1547,7 @@ void tst_Tasking::testTree_data() }, Group { groupSetup(3), - createDynamicTask(3, TaskAction::StopWithError) + createDynamicTask(3, SetupResult::StopWithError) }, Group { groupSetup(4), @@ -1644,7 +1644,7 @@ void tst_Tasking::testTree_data() }, Group { groupSetup(3), - Group { createDynamicTask(3, TaskAction::StopWithDone) } + Group { createDynamicTask(3, SetupResult::StopWithDone) } }, Group { groupSetup(4), @@ -1689,7 +1689,7 @@ void tst_Tasking::testTree_data() }, Group { groupSetup(3), - Group { createDynamicTask(3, TaskAction::StopWithError) } + Group { createDynamicTask(3, SetupResult::StopWithError) } }, Group { groupSetup(4),