bsc::task::TaskRunner Class Reference

#include <TaskRunner.hpp>

Classes
struct	TaskState

Public Member Functions
	~TaskRunner ()
void	every (const std::string &name, std::chrono::milliseconds interval, std::function< void()> fn)
bool	stop_task (const std::string &name)
bool	has_task (const std::string &name) const
void	stop ()

Private Attributes
std::mutex	mutex_
std::unordered_map< std::string, std::unique_ptr< TaskState > >	tasks_
std::atomic_bool	shutdown_ {false}

Detailed Description

Definition at line 13 of file TaskRunner.hpp.

Constructor & Destructor Documentation

~TaskRunner()

bsc::task::TaskRunner::~TaskRunner

(

)

Definition at line 7 of file TaskRunner.cpp.

{ stop(); }

References stop().

Member Function Documentation

every()

void bsc::task::TaskRunner::every	(	const std::string &	name,
		std::chrono::milliseconds	interval,
		std::function< void()>	fn )

Definition at line 9 of file TaskRunner.cpp.

                                                                                                    {
    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);
}

References mutex_, shutdown_, stop_task(), and tasks_.

Referenced by bsc::service::DaemonService::run().

has_task()

bool bsc::task::TaskRunner::has_task

(

const std::string &

name

)

const

Definition at line 44 of file TaskRunner.cpp.

                                                     {
    std::lock_guard lock(mutex_);
    return tasks_.contains(name);
}

References mutex_, and tasks_.

stop()

void bsc::task::TaskRunner::stop

(

)

Definition at line 49 of file TaskRunner.cpp.

                      {
    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();
}

References _, mutex_, shutdown_, and tasks_.

Referenced by ~TaskRunner().

stop_task()

bool bsc::task::TaskRunner::stop_task

(

const std::string &

name

)

Definition at line 30 of file TaskRunner.cpp.

                                                {
    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;
}

References mutex_, and tasks_.

Referenced by every().

Member Data Documentation

mutex_

std::mutex bsc::task::TaskRunner::mutex_

mutableprivate

Definition at line 30 of file TaskRunner.hpp.

Referenced by every(), has_task(), stop(), and stop_task().

shutdown_

std::atomic_bool bsc::task::TaskRunner::shutdown_ {false}

private

Definition at line 32 of file TaskRunner.hpp.

Referenced by every(), and stop().

tasks_

std::unordered_map<std::string, std::unique_ptr<TaskState> > bsc::task::TaskRunner::tasks_

private

Definition at line 31 of file TaskRunner.hpp.

Referenced by every(), has_task(), stop(), and stop_task().

---

The documentation for this class was generated from the following files:

• BastionGuard/thirdparty/bastionguard-secure-connection/daemon/include/bsc/task/TaskRunner.hpp
• BastionGuard/thirdparty/bastionguard-secure-connection/daemon/src/task/TaskRunner.cpp