refactor: make SequentialTask inherit from ConcurrentTask

In a way, sequential tasks are just concurrent tasks with only a single
task running concurrently, so we can remove LOTS of duplicated logic :)

Signed-off-by: flow <flowlnlnln@gmail.com>

launcher/tasks/SequentialTask.cpp

@@ -2,107 +2,21 @@
 
 #include <QDebug>
 
-SequentialTask::SequentialTask(QObject* parent, const QString& task_name) : Task(parent), m_name(task_name), m_currentIndex(-1) {}
+SequentialTask::SequentialTask(QObject* parent, QString task_name) : ConcurrentTask(parent, task_name, 1) {}
-
-SequentialTask::~SequentialTask()
-{
-    for(auto task : m_queue){
-        if(task)
-            task->deleteLater();
-    }
-}
-
-auto SequentialTask::getStepProgress() const -> qint64
-{
-    return m_stepProgress;
-}
-
-auto SequentialTask::getStepTotalProgress() const -> qint64
-{
-    return m_stepTotalProgress;
-}
-
-void SequentialTask::addTask(Task::Ptr task)
-{
-    m_queue.append(task);
-}
-
-void SequentialTask::executeTask()
-{
-    m_currentIndex = -1;
-    startNext();
-}
-
-bool SequentialTask::abort()
-{
-    if(m_currentIndex == -1 || m_currentIndex >= m_queue.size()) {
-        if(m_currentIndex == -1) {
-            // Don't call emitAborted() here, we want to bypass the 'is the task running' check
-            emit aborted();
-            emit finished();
-        }
-
-        m_aborted = true;
-        return true;
-    }
-
-    bool succeeded = m_queue[m_currentIndex]->abort();
-    m_aborted = succeeded;
-
-    if (succeeded)
-        emitAborted();
-
-    return succeeded;
-}
 
 void SequentialTask::startNext()
 {
-    if (m_aborted)
+    if (m_failed.size() > 0) {
-        return;
+        emitFailed(tr("One of the tasks failed!"));
-
+        qWarning() << m_failed.constBegin()->get()->failReason();
-    if (m_currentIndex != -1 && m_currentIndex < m_queue.size()) {
-        Task::Ptr previous = m_queue.at(m_currentIndex);
-        disconnect(previous.get(), 0, this, 0);
-    }
-
-    m_currentIndex++;
-    if (m_queue.isEmpty() || m_currentIndex >= m_queue.size()) {
-        emitSucceeded();
-        return;
-    }
-    Task::Ptr next = m_queue[m_currentIndex];
-
-    connect(next.get(), SIGNAL(failed(QString)), this, SLOT(subTaskFailed(QString)));
-    connect(next.get(), SIGNAL(succeeded()), this, SLOT(startNext()));
-
-    connect(next.get(), SIGNAL(status(QString)), this, SLOT(subTaskStatus(QString)));
-    connect(next.get(), SIGNAL(stepStatus(QString)), this, SLOT(subTaskStatus(QString)));
-    
-    connect(next.get(), SIGNAL(progress(qint64, qint64)), this, SLOT(subTaskProgress(qint64, qint64)));
-
-    setStatus(tr("Executing task %1 out of %2").arg(m_currentIndex + 1).arg(m_queue.size()));
-    setStepStatus(next->isMultiStep() ? next->getStepStatus() : next->getStatus());
-
-    setProgress(m_currentIndex + 1, m_queue.count());
-
-    next->start();
-}
-
-void SequentialTask::subTaskFailed(const QString& msg)
-{
-    emitFailed(msg);
-}
-void SequentialTask::subTaskStatus(const QString& msg)
-{
-    setStepStatus(msg);
-}
-void SequentialTask::subTaskProgress(qint64 current, qint64 total)
-{
-    if (total == 0) {
-        setProgress(0, 100);
         return;
     }
 
-    m_stepProgress = current;
+    ConcurrentTask::startNext();
-    m_stepTotalProgress = total;
+}
+
+void SequentialTask::updateState()
+{
+    setProgress(m_done.count(), m_total_size);
+    setStatus(tr("Executing task %1 out of %2").arg(QString::number(m_doing.count() + m_done.count()), QString::number(m_total_size)));
 }

launcher/tasks/SequentialTask.h

@@ -1,49 +1,21 @@
 #pragma once
 
-#include "Task.h"
+#include "ConcurrentTask.h"
-#include "QObjectPtr.h"
 
-#include <QQueue>
+/** A concurrent task that only allows one concurrent task :)
-
+ *
-class SequentialTask : public Task
+ *  This should be used when there's a need to maintain a strict ordering of task executions, and
-{
+ *  the starting of a task is contingent on the success of the previous one.
+ *
+ *  See MultipleOptionsTask if that's not the case.
+ */
+class SequentialTask : public ConcurrentTask {
     Q_OBJECT
-public:
+   public:
-    explicit SequentialTask(QObject *parent = nullptr, const QString& task_name = "");
+    explicit SequentialTask(QObject* parent = nullptr, QString task_name = "");
-    virtual ~SequentialTask();
+    ~SequentialTask() override = default;
 
-    inline auto isMultiStep() const -> bool override { return m_queue.size() > 1; };
+   protected:
-    auto getStepProgress() const -> qint64 override;
+    void startNext() override;
-    auto getStepTotalProgress() const -> qint64 override;
+    void updateState() override;
-
-    inline auto getStepStatus() const -> QString override { return m_step_status; }
-
-    void addTask(Task::Ptr task);
-
-public slots:
-    bool abort() override;
-
-protected
-slots:
-    void executeTask() override;
-
-    virtual void startNext();
-    virtual void subTaskFailed(const QString &msg);
-    virtual void subTaskStatus(const QString &msg);
-    virtual void subTaskProgress(qint64 current, qint64 total);
-
-protected:
-    void setStepStatus(QString status) { m_step_status = status; emit stepStatus(status); };
-
-protected:
-    QString m_name;
-    QString m_step_status;
-
-    QQueue<Task::Ptr > m_queue;
-    int m_currentIndex;
-
-    qint64 m_stepProgress = 0;
-    qint64 m_stepTotalProgress = 100;
-
-    bool m_aborted = false;
 };