tasl_pool

namespace task_pool_util

template<class Function>
class _Impl : public task_pool_util::_ImplBase

Public Functions

inline _Impl(Function &&f)

inline virtual void run() override

Private Members

Function _func

class _ImplBase

Subclassed by task_pool_util::_Impl< Function >

Public Functions

virtual void run() = 0

inline virtual ~_ImplBase() = default

class TaskPool

Subclassed by thread_pool_util::ThreadPool

Public Types

typedef std::unique_ptr<_ImplBase> __task

typedef std::chrono::steady_clock::time_point __time_point

typedef _ImplBase *task_id_t

Public Functions

inline bool cancel(task_id_t task_id)

template<class X, class Y>
inline void delay(task_id_t task_id, std::chrono::duration<X, Y> duration)

Parameters:

duration – The delay before executing the task

inline std::optional<__time_point> next()

inline TaskPool &operator=(TaskPool &&other) noexcept

inline std::optional<__task> pop()

inline std::optional<std::pair<__time_point, __task>> pop(task_id_t task_id)

template<class Function, class ...Args>
inline auto push(Function &&newTask, Args&&... args)

template<class Function, class X, class Y, class ...Args>
inline auto pushDelayed(Function &&newTask, std::chrono::duration<X, Y> duration, Args&&... args)

Returns:

an id to potentially delay the task

inline void pushDelayed(std::pair<__time_point, __task> &&task)

inline bool ready()

TaskPool() = default

inline TaskPool(TaskPool &&other) noexcept

Protected Attributes

std::mutex _task_mutex

std::deque<__task> _tasks

std::vector<std::pair<__time_point, __task>> _timer_tasks

Private Functions

template<class Function>
inline std::unique_ptr<_ImplBase> toRunnable(Function &&f)

template<class R>
class timer_task_t

Public Functions

inline timer_task_t(task_id_t task_id, std::future<R> &future)

Public Members

std::future<R> future

task_id_t task_id