executor.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <threadman/display.hpp>
#include <threadman/log.hpp>
 
#include <commons/display_info.hpp>
 
#include <concepts>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
 
namespace threadman {
 
class IExecutor {
public:
    virtual ~IExecutor() = default;
    virtual void execute(std::function<void()> task) = 0;
    [[nodiscard]] virtual std::string_view name() const noexcept = 0;
};
 
template <class E>
concept Executor = requires(E& e, std::function<void()> f) {
    { e.execute(std::move(f)) } -> std::same_as<void>;
};
 
namespace detail {
 
inline void execute_on(IExecutor& exec, std::function<void()> task) {
    exec.execute(std::move(task));
}
 
template <class Exec>
    requires(Executor<Exec> && !std::is_same_v<Exec, IExecutor>)
inline void execute_on(Exec& exec, std::function<void()> task) {
    exec.execute(std::move(task));
}
 
}  // namespace detail
 
class InlineExecutor final : public IExecutor {
public:
    [[nodiscard]] static InlineExecutor& instance() noexcept {
        static InlineExecutor inst;
        return inst;
    }
 
    void execute(const std::function<void()> task) override {
        if (task) {
            task();
        }
    }
 
    [[nodiscard]] std::string_view name() const noexcept override {
        return "inline";
    }
 
    [[nodiscard]] static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "InlineExecutor",
            .description = "Executor that runs tasks synchronously on the calling thread.",
            .icon = comms::Icon::from("mdi:flash"),
        };
        return info;
    }
 
private:
    InlineExecutor() = default;
};
 
template <class Exec>
    requires Executor<Exec>
class ExecutorRef final : public IExecutor {
public:
    explicit ExecutorRef(Exec& e, std::string nm = {}) noexcept : exec_(&e), name_(std::move(nm)) {}
 
    void execute(std::function<void()> task) override {
        exec_->execute(std::move(task));
    }
    [[nodiscard]] std::string_view name() const noexcept override {
        return name_.empty() ? std::string_view{"executor-ref"} : std::string_view{name_};
    }
 
private:
    Exec* exec_;
    std::string name_;
};
 
}  // namespace threadman