Async/Utilities.h

Go to the documentation of this file.

 
#ifndef LLU_ASYNC_UTILITIES_H
#define LLU_ASYNC_UTILITIES_H
 
#include <functional>
#include <future>
#include <memory>
#include <thread>
#include <vector>
 
namespace LLU::Async {
 
    class FunctionWrapper {
        struct TypeErasedCallableBase {
            virtual void call() = 0;
            virtual ~TypeErasedCallableBase() = default;
        };
 
        template<typename F>
        struct TypeErasedCallable : TypeErasedCallableBase {
            explicit TypeErasedCallable(F&& f) : callable(std::forward<F>(f)) {}
 
            void call() override {
                callable();
            }
            F callable;
        };
 
    public:
        template<typename F, typename = std::enable_if_t<!std::is_same_v<std::remove_cv<F>, FunctionWrapper>>>
        explicit FunctionWrapper(F&& f) : impl {std::make_unique<TypeErasedCallable<F>>(std::forward<F>(f))} {}
 
        template<typename F, typename... Args>
        explicit FunctionWrapper(F&& f, Args&&... args) {
            auto boundF = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
            impl = std::make_unique<TypeErasedCallable<F>>(std::move(boundF));
        }
 
        FunctionWrapper() = default;
        FunctionWrapper(FunctionWrapper&& other) noexcept = default;
        FunctionWrapper& operator=(FunctionWrapper&& other) noexcept = default;
        FunctionWrapper(const FunctionWrapper&) = delete;
        FunctionWrapper& operator=(const FunctionWrapper&) = delete;
        ~FunctionWrapper() = default;
 
        void operator()() {
            impl->call();
        }
 
    private:
        std::unique_ptr<TypeErasedCallableBase> impl = nullptr;
    };
 
    class ThreadJoiner {
        std::vector<std::thread>& threads;
 
    public:
        explicit ThreadJoiner(std::vector<std::thread>& threadsToJoin) : threads(threadsToJoin) {}
 
        ThreadJoiner(const ThreadJoiner&) = delete;
        ThreadJoiner& operator=(const ThreadJoiner&) = delete;
        ThreadJoiner(ThreadJoiner&&) = delete;
        ThreadJoiner& operator=(ThreadJoiner&&) = delete;
 
        ~ThreadJoiner() {
            for (auto& t : threads) {
                if (t.joinable()) {
                    t.join();
                }
            }
        }
    };
 
    template<typename FunctionType, typename... Args>
    std::packaged_task<std::invoke_result_t<FunctionType, Args...>()> getPackagedTask(FunctionType&& f, Args&&... args) {
        using result_type = std::invoke_result_t<FunctionType, Args...>;
        // NOLINTNEXTLINE(modernize-avoid-bind): perfect forwarding capture of a parameter pack in a lambda is not trivial
        auto boundF = std::bind(std::forward<FunctionType>(f), std::forward<Args>(args)...);
        return std::packaged_task<result_type()> {std::move(boundF)};
    }
 
    class Pausable {
        std::atomic_bool pausedQ = false;
        std::mutex workersMutex;
        std::condition_variable pausedWorkers;
    public:
 
        void checkPause() {
            if (pausedQ) {
                std::unique_lock lck {workersMutex};
                pausedWorkers.wait(lck, [&]() -> bool { return !pausedQ; });
            }
        }
 
        void pause() noexcept {
            pausedQ = true;
        }
 
        void resume() noexcept {
            pausedQ = false;
            pausedWorkers.notify_all();
        }
    };
} // namespace LLU::Async
 
#endif    // LLU_ASYNC_UTILITIES_H