task_manager.hpp

#pragma once
 
#include "fly/task/types.hpp"
#include "fly/types/concurrency/concurrent_queue.hpp"
 
#include <atomic>
#include <chrono>
#include <future>
#include <memory>
#include <mutex>
#include <vector>
 
namespace fly::task {
 
class TaskRunner;
 
class TaskManager : public std::enable_shared_from_this<TaskManager>
{
    friend class TaskRunner;
 
public:
    static std::shared_ptr<TaskManager> create(std::uint32_t thread_count);
 
    bool start();
 
    bool stop();
 
private:
    struct TaskHolder
    {
        TaskLocation m_location;
        std::weak_ptr<TaskRunner> m_weak_task_runner;
        std::chrono::steady_clock::time_point m_schedule;
        Task m_task;
    };
 
    explicit TaskManager(std::uint32_t thread_count) noexcept;
 
    void
    post_task(TaskLocation &&location, std::weak_ptr<TaskRunner> weak_task_runner, Task &&task);
 
    void post_task_with_delay(
        TaskLocation &&location,
        std::weak_ptr<TaskRunner> weak_task_runner,
        std::chrono::milliseconds delay,
        Task &&task);
 
    void worker_thread();
 
    void timer_thread();
 
    fly::ConcurrentQueue<TaskHolder> m_tasks;
 
    std::mutex m_delayed_tasks_mutex;
    std::vector<TaskHolder> m_delayed_tasks;
 
    std::atomic_bool m_keep_running;
 
    std::vector<std::future<void>> m_futures;
 
    std::uint32_t m_thread_count;
};
 
} // namespace fly::task