handler_service.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "co_usb/ev/any_event_handler.hpp"
#include "co_usb/ev/detail/event_handler.hpp"
#include "co_usb/ev/event_handler_ref.hpp"
#include "co_usb/usb_error.hpp"
#include <boost/capy/ex/execution_context.hpp>
#include <boost/capy/ex/executor_ref.hpp>
#include <concepts>
#include <libusb.h>
#include <span>
#include <stdexcept>
#include <stop_token>
#include <system_error>
#include <utility>
 
namespace co_usb
{
struct context;
}
 
namespace co_usb::ev::detail
{
 
struct handler_service : public boost::capy::execution_context::service
{
    friend struct co_usb::context;
 
    explicit handler_service (boost::capy::execution_context &exec_ctx)
        : boost::capy::execution_context::service{}, m_handler{}
    {
    }
 
    ~handler_service () override
    {
        shutdown();
        libusb_exit(m_usb_ctx);
    }
 
    auto init_context () noexcept -> std::error_code
    {
        libusb_context *ctx;
        auto r = libusb_init(&ctx);
        if (r != LIBUSB_SUCCESS)
        {
            return make_usb_error_code(static_cast<usb_error>(r));
        }
        if (m_usb_ctx)
        {
            libusb_exit(m_usb_ctx);
        }
        m_usb_ctx = ctx;
        return {};
    }
 
    auto init_context (std::span<const libusb_init_option> options) noexcept -> std::error_code
    {
        libusb_context *ctx;
        auto r = libusb_init_context(&ctx, options.data(), options.size());
        if (r != LIBUSB_SUCCESS)
        {
            return make_usb_error_code(static_cast<usb_error>(r));
        }
        if (m_usb_ctx)
        {
            libusb_exit(m_usb_ctx);
        }
        m_usb_ctx = ctx;
        return {};
    }
 
    template <detail::EventHandler HandlerTy, typename... Args>
        requires(!std::same_as<HandlerTy, any_event_handler> &&
                 !std::same_as<HandlerTy, event_handler_ref> &&
                 std::constructible_from<HandlerTy, Args...>)
    auto emplace_handler (Args &&...args,
                          std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        -> event_handler_ref
    {
        if (m_handler.valid())
        {
            m_stop.request_stop();
            m_handler.stop();
            m_stop = std::stop_source{};
        }
        m_handler.emplace<HandlerTy>(memres, std::forward<Args>(args)...);
        return m_handler;
    }
 
    auto get_token () const noexcept -> std::stop_token
    {
        return m_stop.get_token();
    }
 
    auto request_stop ()
    {
        libusb_interrupt_event_handler(m_usb_ctx);
        m_stop.request_stop();
    }
 
    auto handler () -> event_handler_ref
    {
        return m_handler;
    }
 
    auto start () -> bool
    {
        return m_handler.start(m_usb_ctx, m_stop.get_token());
    }
 
    auto shutdown () -> void override
    {
        m_stop.request_stop();
        m_handler.stop();
    }
 
    auto usb_context () -> libusb_context *
    {
        return m_usb_ctx;
    }
 
  private:
    any_event_handler m_handler;
    std::stop_source m_stop;
    libusb_context *m_usb_ctx{nullptr};
};
 
inline auto get_handler_service (boost::capy::executor_ref exec) -> handler_service &
{
    handler_service *srv = exec.context().find_service<handler_service>();
    if (!srv)
        throw std::runtime_error{"co_usb handler service is not present"};
    return *srv;
}
 
inline auto nothrow_get_handler_service (boost::capy::executor_ref exec) -> handler_service *
{
    handler_service *srv = exec.context().find_service<handler_service>();
    return srv;
}
 
} // namespace co_usb::ev::detail