callback.hpp

浏览该文件的文档.

 
#pragma once
 
#include <concepts>
#include <functional>
#include <exception>
#include <type_traits>
#include <tuple>
#include <vector>
#include <utility>
 
#include "core/async.hpp"
 
namespace roboctrl {
 
template<typename F, typename... Args>
concept callback_fn = std::invocable<F, Args...> &&
    (std::same_as<std::invoke_result_t<F, Args...>, void> ||
     std::same_as<std::invoke_result_t<F, Args...>, awaitable<void>>);
 
template<typename... Args>
class callback {
public:
    callback() = default;
 
    void operator()(Args... args) const {
        // Coroutine parameters are owned by the frame. A temporary capturing
        // coroutine lambda would retain a dangling pointer to its closure.
        roboctrl::spawn(invoke_callbacks(fns_, std::make_tuple(std::move(args)...)));
    }
 
    template<callback_fn<Args...> F>
    void add(F&& f) {
        using result_t = std::invoke_result_t<F, Args...>;
        if constexpr (std::same_as<result_t, awaitable<void>>) {
            fns_.push_back(std::function<awaitable<void>(Args...)>(std::forward<F>(f)));
        } else {
            fns_.push_back(std::function<awaitable<void>(Args...)>(
                [fn = std::forward<F>(f)](Args... args) mutable -> awaitable<void> {
                    fn(args...);
                    co_return;
                }
            ));
        }
    }
 
private:
    static awaitable<void> invoke_callbacks(
        std::vector<std::function<awaitable<void>(Args...)>> fns,
        std::tuple<std::decay_t<Args>...> call_args) {
        for (auto& fn : fns) {
            try {
                co_await std::apply(fn, call_args);
            } catch (const std::exception& error) {
                logger::instance().log_error("callback failed: {}", error.what());
            } catch (...) {
                logger::instance().log_error("callback failed with an unknown exception");
            }
        }
    }
 
    std::vector<std::function<awaitable<void>(Args...)>> fns_;
};
 
} // namespace roboctrl