partial_io.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "co_usb/ev/detail/handler_service.hpp"
#include "co_usb/ev/event_handler_ref.hpp"
#include "co_usb/transfer/detail/any_buffer_sequence.hpp"
#include "co_usb/transfer/detail/sequence_awaitable.hpp"
#include "co_usb/transfer/detail/transfer_sequence.hpp"
#include "co_usb/transfer/endpoint.hpp"
#include "co_usb/transfer/operations.hpp"
#include "co_usb/transfer/sequence_view.hpp"
#include <boost/capy/buffers.hpp>
#include <boost/capy/ex/executor_ref.hpp>
#include <boost/capy/ex/this_coro.hpp>
#include <boost/capy/io_task.hpp>
 
namespace co_usb::transfer
{
 
namespace detail
{
template <detail::TransferSequence TSeq> struct partial_io_base
{
    explicit partial_io_base (boost::capy::executor_ref exec, TSeq const &tfer_seq)
        : m_ev_ref(::co_usb::ev::detail::get_handler_service(exec).handler()), m_view(tfer_seq)
    {
    }
 
    template <detail::AnyBufferSequence BuffersTy>
    auto submit (BuffersTy const &buffers) -> boost::capy::io_task<size_t>
    {
        auto exec = co_await boost::capy::this_coro::executor;
        auto stop = co_await boost::capy::this_coro::stop_token;
 
        const size_t transfers_used = std::min(boost::capy::buffer_length(buffers), m_view.size());
        std::stop_callback sb{stop, [&] ()
                              {
                                  const auto end = m_view.begin() + transfers_used;
                                  for (auto iter = m_view.begin(); iter != end; iter++)
                                  {
                                      libusb_transfer *tfer = detail::transfer_of(*iter);
                                      cancel_transfer(tfer);
                                  }
                              }};
        using awaitable_t = detail::sequence_awaitable<TSeq, BuffersTy>;
        typename awaitable_t::await_state_t await_state;
        co_return co_await awaitable_t(&await_state, &m_view, buffers, transfers_used);
    }
 
  protected:
    ev::event_handler_ref m_ev_ref;
    sequence_view<TSeq> m_view;
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct direction_partial_io_base
{
    explicit direction_partial_io_base (boost::capy::executor_ref exec, TSeq const &tfer_seq)
        : m_stream(exec, tfer_seq)
    {
    }
 
    template <boost::capy::MutableBufferSequence BuffersTy>
        requires(EpDirection == endpoint_direction::in)
    inline auto read_some (BuffersTy const &buffers) -> boost::capy::io_task<size_t>
    {
        return m_stream.submit(buffers);
    }
 
    template <boost::capy::ConstBufferSequence BuffersTy>
        requires(EpDirection == endpoint_direction::out)
    inline auto write_some (BuffersTy const &buffers) -> boost::capy::io_task<size_t>
    {
        return m_stream.submit(buffers);
    }
 
  private:
    partial_io_base<TSeq> m_stream;
};
} // namespace detail
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct control_partial_io : detail::direction_partial_io_base<TSeq, EpDirection>
{
    explicit control_partial_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0})
        : detail::direction_partial_io_base<TSeq, EpDirection>(exec, tfer_seq)
    {
        prefill_control(tfer_seq, endpoint, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct bulk_partial_io : detail::direction_partial_io_base<TSeq, EpDirection>
{
    explicit bulk_partial_io (boost::capy::executor_ref exec, TSeq const &tfer_seq,
                              endpoint<EpDirection> endpoint,
                              std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0})
        : detail::direction_partial_io_base<TSeq, EpDirection>(exec, tfer_seq)
    {
        prefill_bulk(tfer_seq, endpoint, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct interrupt_partial_io : detail::direction_partial_io_base<TSeq, EpDirection>
{
    explicit interrupt_partial_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0})
        : detail::direction_partial_io_base<TSeq, EpDirection>(exec, tfer_seq)
    {
        prefill_interrupt(tfer_seq, endpoint, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct isochronous_partial_io : detail::direction_partial_io_base<TSeq, EpDirection>
{
    explicit isochronous_partial_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        int iso_packets, std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0})
        : detail::direction_partial_io_base<TSeq, EpDirection>(exec, tfer_seq)
    {
        prefill_isochronous(tfer_seq, endpoint, iso_packets, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct bulk_stream_partial_io : detail::direction_partial_io_base<TSeq, EpDirection>
{
    explicit bulk_stream_partial_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        uint32_t stream_id, std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0})
        : detail::direction_partial_io_base<TSeq, EpDirection>(exec, tfer_seq)
    {
        prefill_bulk_stream(tfer_seq, endpoint, stream_id, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq>
using control_out = control_partial_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using control_in = control_partial_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using bulk_out = bulk_partial_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using bulk_in = bulk_partial_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using interrupt_out = interrupt_partial_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using interrupt_in = interrupt_partial_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using isochronous_out = isochronous_partial_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using isochronous_in = isochronous_partial_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using bulk_stream_out = bulk_stream_partial_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using bulk_stream_in = bulk_stream_partial_io<TSeq, endpoint_direction::in>;
 
} // namespace co_usb::transfer