TaskManager.h

#pragma once
 
 
#include <vector>
 
#include "Task.h"
 
NAMESPACE_SQUID_BEGIN
 
//--- TaskManager ---//
class TaskManager
{
public:
    ~TaskManager() {} 
 
    template <typename tRet>
    SQUID_NODISCARD TaskHandle<tRet> Run(Task<tRet>&& in_task)
    {
        // Run unmanaged task
        TaskHandle<tRet> taskHandle = in_task;
        WeakTask weakTask = std::move(in_task);
        RunWeakTask(std::move(weakTask));
        return taskHandle;
    }
    template <typename tRet>
    SQUID_NODISCARD TaskHandle<tRet> Run(const Task<tRet>& in_task) 
    {
        static_assert(static_false<tRet>::value, "Cannot run an unmanaged task by copy (try Run(std::move(task)))");
        return {};
    }
 
    template <typename tRet>
    WeakTaskHandle RunManaged(Task<tRet>&& in_task)
    {
        // Run managed task
        WeakTaskHandle weakTaskHandle = in_task;
        m_strongRefs.push_back(Run(std::move(in_task)));
        return weakTaskHandle;
    }
    template <typename tRet>
    WeakTaskHandle RunManaged(const Task<tRet>& in_task) 
    {
        static_assert(static_false<tRet>::value, "Cannot run a managed task by copy (try RunManaged(std::move(task)))");
        return {};
    }
 
    void RunWeakTask(WeakTask&& in_task)
    {
        // Run unmanaged task
        m_tasks.push_back(std::move(in_task));
    }
 
    void KillAllTasks()
    {
        m_tasks.clear(); // Destroying all the weak tasks implicitly destroys all internal tasks
 
        // No need to call Kill() on each TaskHandle in m_strongRefs
        m_strongRefs.clear(); // Handles in the strong refs array only ever point to tasks in the now-cleared m_tasks array
    }
 
    Task<> StopAllTasks()
    {
        // Request stop on all tasks
        std::vector<WeakTaskHandle> weakHandles;
        for(auto& task : m_tasks)
        {
            task.RequestStop();
            weakHandles.push_back(task);
        }
 
        // Return a fence task that waits until all stopped tasks are complete
        return [](std::vector<WeakTaskHandle> in_weakHandles) -> Task<> {
            TASK_NAME("StopAllTasks() Fence Task");
            for(const auto& weakHandle : in_weakHandles)
            {
                co_await weakHandle; // Wait until task is complete
            }
        }(std::move(weakHandles));
    }
 
    void Update()
    {
        // Resume all tasks
        size_t writeIdx = 0;
        for(size_t readIdx = 0; readIdx < m_tasks.size(); ++readIdx)
        {
            if(m_tasks[readIdx].Resume() != eTaskStatus::Done)
            {
                if(writeIdx != readIdx)
                {
                    m_tasks[writeIdx] = std::move(m_tasks[readIdx]);
                }
                ++writeIdx;
            }
        }
        m_tasks.resize(writeIdx);
 
        // Prune strong tasks that are done
        auto removeIt = m_strongRefs.erase(std::remove_if(m_strongRefs.begin(), m_strongRefs.end(), [](const auto& in_taskHandle) {
            return in_taskHandle.IsDone();
        }), m_strongRefs.end());
    }
 
    std::string GetDebugString(std::optional<TaskDebugStackFormatter> in_formatter = {}) const
    {
        std::string debugStr;
        for(const auto& task : m_tasks)
        {
            if(!task.IsDone())
            {
                if(debugStr.size())
                {
                    debugStr += '\n';
                }
                debugStr += task.GetDebugStack(in_formatter);
            }
        }
        return debugStr;
    }
 
private:
    std::vector<WeakTask> m_tasks;
    std::vector<TaskHandle<>> m_strongRefs;
};
 
NAMESPACE_SQUID_END