#include <gtopt/work_pool.hpp>

template<typename Key = int64_t, typename KeyCompare KeyCompare = std::less<Key>>

gtopt::BasicWorkPool class

Adaptive thread pool with generic priority key.

Template parameters
Key	Secondary sort-key type for task ordering within the same TaskPriority tier. Default is int64_t.
KeyCompare	Comparator applied to keys. Default std::less<Key> gives "smaller key → higher priority". Pass std::greater<Key> to obtain "larger key → higher priority" (the original pre-refactor behavior).

All methods are defined inline here so that any specialization can be instantiated without a separate translation unit.

Derived classes

class AdaptiveWorkPool final

Default work pool using int64_t priority key with std::less semantics (smaller key → higher priority).

Public types

struct Statistics

using key_compare = KeyCompare

using key_type = Key

using Requirements = BasicTaskRequirements<Key>

Constructors, destructors, conversion operators

BasicWorkPool(BasicWorkPool&&) deleted

BasicWorkPool(const BasicWorkPool&) deleted

BasicWorkPool(WorkPoolConfig config = WorkPoolConfig {}) explicit

~BasicWorkPool()

Public functions

auto format_statistics() const -> std::string noexcept

auto get_statistics() const -> Statistics noexcept

auto log_statistics() const -> void

auto operator=(const BasicWorkPool&&) -> BasicWorkPool& deleted

auto operator=(const BasicWorkPool&) -> BasicWorkPool& deleted

auto shutdown() -> void

auto start() -> void

template<typename Func Func, typename... Args>

auto submit(Func&& func, const Requirements& req = Requirements(), Args && ... args) -> std::expected< std::future< std::invoke_result_t< Func, Args... > >, std::error_code > -> auto

template<typename Func Func>

auto submit_lambda(Func&& func, Requirements req = {}) -> auto