async.hpp

浏览该文件的文档.

 
#pragma once
#include <chrono>
#include <format>
#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<>;
 
    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_,
            [fn = std::forward<Fn>(fn),
            args = std::make_tuple(std::decay_t<Args>(std::forward<Args>(args))...)]() mutable {
                return std::apply(std::move(fn), std::move(args));
            });
    }
 
    void run();
 
    void stop();
 
    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:
    asio::io_context context_;
    info_type info_;
};
 
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 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;
}