complete_io.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "co_usb/transfer/detail/any_buffer_sequence.hpp"
#include "co_usb/transfer/detail/complete_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/partial_io.hpp"
#include <boost/capy/io_task.hpp>
#include <memory_resource>
 
namespace co_usb::transfer
{
 
namespace detail
{
template <detail::TransferSequence TSeq> struct complete_io_base : public partial_io_base<TSeq>
{
    explicit complete_io_base (boost::capy::executor_ref exec, TSeq const &tfer_seq,
                               size_t single_transfer_limit,
                               std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : partial_io_base<TSeq>(exec, tfer_seq), m_memres(memres),
          m_single_transfer_limit(single_transfer_limit)
    {
    }
 
    template <detail::AnyBufferSequence BuffersTy>
    auto complete_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), this->m_view.size());
        std::stop_callback sb{stop, [&] ()
                              {
                                  const auto end = this->m_view.begin() + transfers_used;
                                  for (auto iter = this->m_view.begin(); iter != end; iter++)
                                  {
                                      libusb_transfer *tfer = detail::transfer_of(*iter);
                                      cancel_transfer(tfer);
                                  }
                              }};
        using awaitable_t = detail::complete_sequence_awaitable<TSeq, BuffersTy>;
        typename awaitable_t::await_state_t await_state(m_memres);
        co_return co_await awaitable_t(&await_state, &this->m_view, buffers, transfers_used,
                                       m_single_transfer_limit);
    }
 
  private:
    std::pmr::memory_resource *m_memres;
    size_t m_single_transfer_limit;
};
 
template <TransferSequence TSeq, endpoint_direction EpDirection> struct direction_complete_io_base
{
    explicit direction_complete_io_base (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, size_t single_transfer_limit,
        std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : m_raw(exec, tfer_seq, single_transfer_limit, memres)
    {
    }
 
    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_raw.submit(buffers);
    }
 
    template <boost::capy::MutableBufferSequence BuffersTy>
        requires(EpDirection == endpoint_direction::in)
    inline auto read (BuffersTy const &buffers) -> boost::capy::io_task<size_t>
    {
        return m_raw.complete_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_raw.submit(buffers);
    }
 
    template <boost::capy::ConstBufferSequence BuffersTy>
        requires(EpDirection == endpoint_direction::out)
    inline auto write (BuffersTy const &buffers) -> boost::capy::io_task<size_t>
    {
        return m_raw.complete_submit(buffers);
    }
 
    template <boost::capy::ConstBufferSequence BuffersTy>
        requires(EpDirection == endpoint_direction::out)
    inline auto write_eof (BuffersTy const &buffers) -> boost::capy::io_task<size_t>
    {
        return m_raw.complete_submit(buffers);
    }
 
    template <boost::capy::ConstBufferSequence BuffersTy>
        requires(EpDirection == endpoint_direction::out)
    inline auto write_eof () -> boost::capy::io_task<>
    {
        co_return {{}};
    }
 
  private:
    complete_io_base<TSeq> m_raw;
};
 
} // namespace detail
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct control_complete_io : detail::direction_complete_io_base<TSeq, EpDirection>
{
    explicit control_complete_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        size_t single_transfer_limit,
        std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0},
        std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : detail::direction_complete_io_base<TSeq, EpDirection>(exec, tfer_seq,
                                                                single_transfer_limit, memres)
    {
        prefill_control(tfer_seq, endpoint, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct bulk_complete_io : detail::direction_complete_io_base<TSeq, EpDirection>
{
    explicit bulk_complete_io (boost::capy::executor_ref exec, TSeq const &tfer_seq,
                               endpoint<EpDirection> endpoint, size_t single_transfer_limit,
                               std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0},
                               std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : detail::direction_complete_io_base<TSeq, EpDirection>(exec, tfer_seq,
                                                                single_transfer_limit, memres)
    {
        prefill_bulk(tfer_seq, endpoint, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct interrupt_complete_io : detail::direction_complete_io_base<TSeq, EpDirection>
{
    explicit interrupt_complete_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        size_t single_transfer_limit,
        std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0},
        std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : detail::direction_complete_io_base<TSeq, EpDirection>(exec, tfer_seq,
                                                                single_transfer_limit, memres)
    {
        prefill_interrupt(tfer_seq, endpoint, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct isochronous_complete_io : detail::direction_complete_io_base<TSeq, EpDirection>
{
    explicit isochronous_complete_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        int iso_packets, size_t single_transfer_limit,
        std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0},
        std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : detail::direction_complete_io_base<TSeq, EpDirection>(exec, tfer_seq,
                                                                single_transfer_limit, memres)
    {
        prefill_isochronous(tfer_seq, endpoint, iso_packets, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq, endpoint_direction EpDirection>
struct bulk_stream_complete_io : detail::direction_complete_io_base<TSeq, EpDirection>
{
    explicit bulk_stream_complete_io (
        boost::capy::executor_ref exec, TSeq const &tfer_seq, endpoint<EpDirection> endpoint,
        uint32_t stream_id, size_t single_transfer_limit,
        std::chrono::milliseconds timeout_ms = std::chrono::milliseconds{0},
        std::pmr::memory_resource *memres = std::pmr::get_default_resource())
        : detail::direction_complete_io_base<TSeq, EpDirection>(exec, tfer_seq,
                                                                single_transfer_limit, memres)
    {
        prefill_bulk_stream(tfer_seq, endpoint, stream_id, timeout_ms);
    }
};
 
template <detail::TransferSequence TSeq>
using control_sink = control_complete_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using control_source = control_complete_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using bulk_sink = bulk_complete_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using bulk_source = bulk_complete_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using interrupt_sink = interrupt_complete_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using interrupt_source = interrupt_complete_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using isochronous_sink = isochronous_complete_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using isochronous_source = isochronous_complete_io<TSeq, endpoint_direction::in>;
 
template <detail::TransferSequence TSeq>
using bulk_stream_sink = bulk_stream_complete_io<TSeq, endpoint_direction::out>;
 
template <detail::TransferSequence TSeq>
using bulk_stream_source = bulk_stream_complete_io<TSeq, endpoint_direction::in>;
 
} // namespace co_usb::transfer