endpoint.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "co_usb/wrapper/detail/device_handle_source.hpp"
#include <cstdint>
#include <optional>
#include <stdexcept>
 
namespace co_usb::transfer
{
 
enum class endpoint_direction
{
    out = 0x00,
    in = 0x80,
    any = 0xFF,
};
 
template <endpoint_direction Direction = endpoint_direction::any> struct endpoint
{
    template <co_usb::detail::DeviceHandleSource DevSourceTy>
    static endpoint<Direction> make_safe (uint8_t ep, DevSourceTy const &dev_source) noexcept
        requires(Direction != endpoint_direction::any)
    {
        if constexpr (Direction == endpoint_direction::out)
        {
            return endpoint<Direction>{static_cast<uint8_t>(ep & ~LIBUSB_ENDPOINT_IN),
                                       co_usb::detail::device_handle_of(dev_source)};
        }
        else if constexpr (Direction == endpoint_direction::in)
        {
            return endpoint<Direction>{static_cast<uint8_t>(ep | LIBUSB_ENDPOINT_IN),
                                       co_usb::detail::device_handle_of(dev_source)};
        }
        return endpoint<Direction>{ep, co_usb::detail::device_handle_of(dev_source)};
    }
 
    template <co_usb::detail::DeviceHandleSource DevSourceTy>
    static endpoint<Direction> make_unsafe (uint8_t ep, DevSourceTy const &devh) noexcept
    {
        return {ep, co_usb::detail::device_handle_of(devh)};
    }
 
    template <co_usb::detail::DeviceHandleSource DevSourceTy>
    static endpoint<Direction> make_throwing (uint8_t ep, DevSourceTy const &devh)
        requires(Direction != endpoint_direction::any)
    {
        if constexpr (Direction == endpoint_direction::out)
        {
            if (ep & LIBUSB_ENDPOINT_IN)
            {
                throw std::invalid_argument{"Cannot use IN endpoint for OUT"};
            }
        }
        else if constexpr (Direction == endpoint_direction::in)
        {
            if (!(ep & LIBUSB_ENDPOINT_IN))
            {
                throw std::invalid_argument{"Cannot use OUT endpoint for IN"};
            }
        }
        return {ep, co_usb::detail::device_handle_of(devh)};
    }
 
    uint8_t addr () const noexcept
        requires(Direction != endpoint_direction::any)
    {
        return m_ep;
    }
 
    auto devh () const noexcept -> libusb_device_handle *
        requires(Direction != endpoint_direction::any)
    {
        return m_devh;
    }
 
    template <endpoint_direction ToDirection>
    std::optional<endpoint<ToDirection>> as () const noexcept
        requires(Direction == endpoint_direction::any && ToDirection != endpoint_direction::any)
    {
        if constexpr (ToDirection == endpoint_direction::in)
        {
            if (m_ep & LIBUSB_ENDPOINT_IN)
            {
                return endpoint<endpoint_direction::in>::make_unsafe(m_ep, m_devh);
            }
            return std::nullopt;
        }
        else if constexpr (ToDirection == endpoint_direction::out)
        {
            if (m_ep & LIBUSB_ENDPOINT_IN)
            {
                return std::nullopt;
            }
            return endpoint<endpoint_direction::out>::make_unsafe(m_ep, m_devh);
        }
    }
 
  private:
    endpoint (uint8_t ep, libusb_device_handle *devh) noexcept : m_devh(devh), m_ep(ep)
    {
    }
 
  private:
    libusb_device_handle *m_devh;
    uint8_t m_ep;
};
 
inline auto ep_out (uint8_t ep_addr, co_usb::detail::DeviceHandleSource auto const &devh_src)
    -> endpoint<endpoint_direction::out>
{
    return endpoint<endpoint_direction::out>::make_safe(ep_addr, devh_src);
}
 
inline auto ep_in (uint8_t ep_addr, co_usb::detail::DeviceHandleSource auto const &devh_src)
    -> endpoint<endpoint_direction::in>
{
    return endpoint<endpoint_direction::in>::make_safe(ep_addr, devh_src);
}
 
inline auto ep_any (uint8_t ep_addr, co_usb::detail::DeviceHandleSource auto const &devh_src)
    -> endpoint<endpoint_direction::any>
{
    return endpoint<endpoint_direction::any>::make_unsafe(
        ep_addr, co_usb::detail::device_handle_of(devh_src));
}
 
} // namespace co_usb::transfer