handlers.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "co_usb/ev/detail/event_handler.hpp"
#include "co_usb/usb_error.hpp"
#include <atomic>
#include <thread>
 
namespace co_usb::ev
{
struct trivial_event_handler
{
    auto start (libusb_context *usb_ctx, std::stop_token stop) -> bool
    {
        auto handle_fn = [usb_ctx, stop]
        {
            const timeval ctv = {.tv_sec = 0, .tv_usec = 10'000};
            while (!stop.stop_requested())
            {
                timeval tv = ctv;
                auto r = libusb_handle_events_timeout(usb_ctx, &tv);
                if (r != LIBUSB_SUCCESS)
                {
                    throw std::system_error{make_usb_error_code(static_cast<usb_error>(r))};
                }
            }
        };
        m_thread = std::thread{std::move(handle_fn)};
        return true;
    }
 
    auto ref () noexcept
    {
        // no-op, there is nothing to ref
    }
 
    auto unref () noexcept
    {
        // no-op, there is nothing to ref
    }
 
    auto stop ()
    {
        if (m_thread.joinable())
            m_thread.join();
    }
 
    ~trivial_event_handler ()
    {
        stop();
    }
 
  private:
    std::thread m_thread;
};
 
static_assert(detail::EventHandler<trivial_event_handler>, "Not a proper usb event handler");
static_assert(detail::EventHandler<trivial_event_handler>, "Not a proper usb event handler");
 
struct refcounted_event_handler
{
    auto start (libusb_context *usb_ctx, std::stop_token stop) -> bool
    {
        try
        {
            auto handle_fn = [this, usb_ctx, stop]
            {
                const timeval ctv = {.tv_sec = 0, .tv_usec = 10'000};
                for (;;)
                {
                    timeval tv = ctv;
                    auto r = libusb_handle_events_timeout(usb_ctx, &tv);
                    if (r != LIBUSB_SUCCESS) [[unlikely]]
                    {
                        throw std::system_error{
                            make_usb_error_code(static_cast<co_usb::usb_error>(r))};
                    }
 
                    if (stop.stop_requested() && m_counter.load(std::memory_order_acquire) == 0)
                        [[unlikely]]
                    {
                        break;
                    }
                }
            };
            m_thread = std::thread{std::move(handle_fn)};
            return true;
        }
        catch (...)
        {
            return false;
        }
    }
 
    auto ref () noexcept
    {
        m_counter.fetch_add(1, std::memory_order_acquire);
    }
 
    auto unref () noexcept
    {
        m_counter.fetch_sub(1, std::memory_order_release);
    }
 
    auto stop ()
    {
        if (m_thread.joinable())
            m_thread.join();
    }
 
    ~refcounted_event_handler ()
    {
        stop();
    }
 
  private:
    std::atomic_size_t m_counter{0};
    std::thread m_thread;
};
 
static_assert(detail::EventHandler<refcounted_event_handler>, "Not a proper usb event handler");
static_assert(detail::EventHandler<refcounted_event_handler>, "Not a proper usb event handler");
 
} // namespace co_usb::ev