TaskRunner.cpp

Go to the documentation of this file.

#include "bsc/task/TaskRunner.hpp"
 
#include <thread>
 
namespace bsc::task {
 
TaskRunner::~TaskRunner() { stop(); }
 
void TaskRunner::every(const std::string& name, std::chrono::milliseconds interval, std::function<void()> fn) {
    stop_task(name);
    if (shutdown_) return;
 
    auto state = std::make_unique<TaskState>();
    state->interval = interval;
    state->fn = std::move(fn);
    auto* ptr = state.get();
    state->thread = std::thread([this, ptr]() {
        while (!shutdown_ && ptr->running) {
            ptr->fn();
            for (std::chrono::milliseconds elapsed{0}; !shutdown_ && ptr->running && elapsed < ptr->interval; elapsed += std::chrono::milliseconds(100)) {
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
        }
    });
 
    std::lock_guard lock(mutex_);
    tasks_[name] = std::move(state);
}
 
bool TaskRunner::stop_task(const std::string& name) {
    std::unique_ptr<TaskState> task;
    {
        std::lock_guard lock(mutex_);
        auto it = tasks_.find(name);
        if (it == tasks_.end()) return false;
        task = std::move(it->second);
        tasks_.erase(it);
    }
    task->running = false;
    if (task->thread.joinable()) task->thread.join();
    return true;
}
 
bool TaskRunner::has_task(const std::string& name) const {
    std::lock_guard lock(mutex_);
    return tasks_.contains(name);
}
 
void TaskRunner::stop() {
    shutdown_ = true;
    std::unordered_map<std::string, std::unique_ptr<TaskState>> tasks;
    {
        std::lock_guard lock(mutex_);
        tasks.swap(tasks_);
    }
    for (auto& [_, task] : tasks) task->running = false;
    for (auto& [_, task] : tasks) if (task->thread.joinable()) task->thread.join();
}
 
} // namespace bsc::task