async.hpp

浏览该文件的文档.

 
#pragma once
#include <chrono>
#include <exception>
#include <format>
#include <functional>
#include <string_view>
#include <tuple>
#include <utility>
#include <asio.hpp>
#include <asio/awaitable.hpp>
#include <asio/io_context.hpp>
#include <asio/steady_timer.hpp>
#include <asio/use_awaitable.hpp>
 
#include "multiton.hpp"
#include "core/logger.h"
#include "utils/singleton.hpp"
 
namespace roboctrl::async{
 
template<typename T = void>
using awaitable = asio::awaitable<T>;
 
using duration = std::chrono::steady_clock::duration;
 
class task_context :
 public utils::singleton_base<task_context>,public logable<task_context>{
public:
    using task_type = awaitable<>;
    using shutdown_handler_type = std::function<task_type()>;
 
    struct info_type{
        using owner_type = task_context;
    };
 
    explicit task_context();
 
    void spawn(task_type&& task);
 
    template<typename Fn, typename... Args>
    inline void post(Fn&& fn, Args&&... args) {
        asio::post(context_,
            [this, fn = std::forward<Fn>(fn),
            args = std::make_tuple(std::decay_t<Args>(std::forward<Args>(args))...)]() mutable {
                try {
                    std::apply(std::move(fn), std::move(args));
                } catch (...) {
                    handle_unhandled_exception(
                        std::current_exception(), "posted task");
                }
            });
    }
 
    void set_shutdown_handler(shutdown_handler_type handler);
 
    void request_shutdown() noexcept;
 
    void run() noexcept;
 
    void stop();
 
    bool failed() const noexcept { return failed_; }
 
    bool shutdown_requested() const noexcept { return shutdown_started_; }
 
    bool init(info_type _info);
 
    inline std::string desc()const{
        return std::format("async task context");
    }
 
    inline auto get_executor(){
        return context_.get_executor();
    }
 
    inline auto asio_context() -> asio::io_context&{
        return context_;
    }
    
private:
    void handle_unhandled_exception(std::exception_ptr error,
                                    std::string_view origin) noexcept;
    void finish_shutdown(std::exception_ptr error) noexcept;
 
    asio::io_context context_;
    info_type info_;
    shutdown_handler_type shutdown_handler_;
    bool failed_ {false};
    bool shutdown_started_ {false};
};
 
static_assert(utils::singleton_info<task_context::info_type>);
static_assert(utils::singleton<task_context>);
 
inline auto spawn(task_context::task_type&& task){
    roboctrl::get<task_context>().spawn(std::forward<task_context::task_type>(task));
}
 
template<typename ...Args>
inline auto post(Args&&... args)
{
    roboctrl::get<task_context>().post(std::forward<Args>(args)...);
}
 
inline void run(){
    roboctrl::get<task_context>().run();
}
 
inline bool failed(){
    return roboctrl::get<task_context>().failed();
}
 
inline bool shutdown_requested(){
    return roboctrl::get<task_context>().shutdown_requested();
}
 
inline void set_shutdown_handler(task_context::shutdown_handler_type handler){
    roboctrl::get<task_context>().set_shutdown_handler(std::move(handler));
}
 
inline void request_shutdown(){
    roboctrl::get<task_context>().request_shutdown();
}
 
inline awaitable<void> yield(){
    co_await asio::post(asio::use_awaitable);
}
 
inline awaitable<void> wait_for(const duration& duration){
    auto ex = roboctrl::get<task_context>().get_executor();
    asio::steady_timer timer(ex, duration);
    co_await timer.async_wait(asio::use_awaitable);
}
 
inline auto executor(){
    return roboctrl::get<task_context>().get_executor();
}
 
inline auto& io_context(){
    return roboctrl::get<task_context>().asio_context();
}
 
inline void stop(){
    roboctrl::get<task_context>().stop();
}
}
namespace roboctrl{
    using namespace async;
}