Diff coverage report for

//

//

// Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2025 Vinnie Falco (vinnie.falco@gmail.com)

//

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

//

// Official repository: https://github.com/cppalliance/capy

// Official repository: https://github.com/cppalliance/capy

//

//

#ifndef BOOST_CAPY_IO_ANY_BUFFER_SOURCE_HPP

#ifndef BOOST_CAPY_IO_ANY_BUFFER_SOURCE_HPP

#define BOOST_CAPY_IO_ANY_BUFFER_SOURCE_HPP

#define BOOST_CAPY_IO_ANY_BUFFER_SOURCE_HPP

#include <boost/capy/detail/config.hpp>

#include <boost/capy/detail/config.hpp>

#include <boost/capy/detail/await_suspend_helper.hpp>

#include <boost/capy/detail/await_suspend_helper.hpp>

#include <boost/capy/buffers.hpp>

#include <boost/capy/buffers.hpp>

#include <boost/capy/buffers/buffer_copy.hpp>

#include <boost/capy/buffers/buffer_copy.hpp>

#include <boost/capy/buffers/buffer_param.hpp>

#include <boost/capy/buffers/buffer_param.hpp>

#include <boost/capy/buffers/slice.hpp>

#include <boost/capy/buffers/slice.hpp>

#include <boost/capy/concept/buffer_source.hpp>

#include <boost/capy/concept/buffer_source.hpp>

#include <boost/capy/concept/io_awaitable.hpp>

#include <boost/capy/concept/io_awaitable.hpp>

#include <boost/capy/concept/read_source.hpp>

#include <boost/capy/concept/read_source.hpp>

#include <boost/capy/coro.hpp>

#include <boost/capy/coro.hpp>

#include <boost/capy/error.hpp>

#include <boost/capy/error.hpp>

#include <boost/capy/ex/executor_ref.hpp>

#include <boost/capy/ex/executor_ref.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_task.hpp>

#include <boost/capy/io_task.hpp>

#include <concepts>

#include <concepts>

#include <coroutine>

#include <coroutine>

#include <cstddef>

#include <cstddef>

#include <exception>

#include <exception>

#include <new>

#include <new>

#include <span>

#include <span>

#include <stop_token>

#include <stop_token>

#include <system_error>

#include <system_error>

#include <utility>

#include <utility>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** Type-erased wrapper for any BufferSource.

/** Type-erased wrapper for any BufferSource.

    This class provides type erasure for any type satisfying the

    This class provides type erasure for any type satisfying the

    @ref BufferSource concept, enabling runtime polymorphism for

    @ref BufferSource concept, enabling runtime polymorphism for

    buffer pull operations. It uses cached awaitable storage to achieve

    buffer pull operations. It uses cached awaitable storage to achieve

    zero steady-state allocation after construction.

    zero steady-state allocation after construction.

    The wrapper also satisfies @ref ReadSource. When the wrapped type

    The wrapper also satisfies @ref ReadSource. When the wrapped type

    satisfies only @ref BufferSource, the read operations are

    satisfies only @ref BufferSource, the read operations are

    synthesized using @ref pull and @ref consume with an extra

    synthesized using @ref pull and @ref consume with an extra

    buffer copy. When the wrapped type satisfies both @ref BufferSource

    buffer copy. When the wrapped type satisfies both @ref BufferSource

    and @ref ReadSource, the native read operations are forwarded

    and @ref ReadSource, the native read operations are forwarded

    directly across the virtual boundary, avoiding the copy.

    directly across the virtual boundary, avoiding the copy.

    The wrapper supports two construction modes:

    The wrapper supports two construction modes:

    - **Owning**: Pass by value to transfer ownership. The wrapper

    - **Owning**: Pass by value to transfer ownership. The wrapper

      allocates storage and owns the source.

      allocates storage and owns the source.

    - **Reference**: Pass a pointer to wrap without ownership. The

    - **Reference**: Pass a pointer to wrap without ownership. The

      pointed-to source must outlive this wrapper.

      pointed-to source must outlive this wrapper.

    Within each mode, the vtable is populated at compile time based

    Within each mode, the vtable is populated at compile time based

    on whether the wrapped type also satisfies @ref ReadSource:

    on whether the wrapped type also satisfies @ref ReadSource:

    - **BufferSource only**: @ref read_some and @ref read are

    - **BufferSource only**: @ref read_some and @ref read are

      synthesized from @ref pull and @ref consume, incurring one

      synthesized from @ref pull and @ref consume, incurring one

      buffer copy per operation.

      buffer copy per operation.

    - **BufferSource + ReadSource**: All read operations are

    - **BufferSource + ReadSource**: All read operations are

      forwarded natively through the type-erased boundary with

      forwarded natively through the type-erased boundary with

      no extra copy.

      no extra copy.

    @par Awaitable Preallocation

    @par Awaitable Preallocation

    The constructor preallocates storage for the type-erased awaitable.

    The constructor preallocates storage for the type-erased awaitable.

    This reserves all virtual address space at server startup

    This reserves all virtual address space at server startup

    so memory usage can be measured up front, rather than

    so memory usage can be measured up front, rather than

    allocating piecemeal as traffic arrives.

    allocating piecemeal as traffic arrives.

    @par Thread Safety

    @par Thread Safety

    Not thread-safe. Concurrent operations on the same wrapper

    Not thread-safe. Concurrent operations on the same wrapper

    are undefined behavior.

    are undefined behavior.

    @par Example

    @par Example

    @code

    @code

    // Owning - takes ownership of the source

    // Owning - takes ownership of the source

    any_buffer_source abs(some_buffer_source{args...});

    any_buffer_source abs(some_buffer_source{args...});

    // Reference - wraps without ownership

    // Reference - wraps without ownership

    some_buffer_source src;

    some_buffer_source src;

    any_buffer_source abs(&src);

    any_buffer_source abs(&src);

    const_buffer arr[16];

    const_buffer arr[16];

    auto [ec, bufs] = co_await abs.pull(arr);

    auto [ec, bufs] = co_await abs.pull(arr);

    // ReadSource interface also available

    // ReadSource interface also available

    char buf[64];

    char buf[64];

    auto [ec2, n] = co_await abs.read_some(mutable_buffer(buf, 64));

    auto [ec2, n] = co_await abs.read_some(mutable_buffer(buf, 64));

    @endcode

    @endcode

    @see any_buffer_sink, BufferSource, ReadSource

    @see any_buffer_sink, BufferSource, ReadSource

*/

*/

class any_buffer_source

class any_buffer_source

{

{

    struct vtable;

    struct vtable;

    struct awaitable_ops;

    struct awaitable_ops;

    struct read_awaitable_ops;

    struct read_awaitable_ops;

    template<BufferSource S>

    template<BufferSource S>

    struct vtable_for_impl;

    struct vtable_for_impl;

    // hot-path members first for cache locality

    // hot-path members first for cache locality

    void* source_ = nullptr;

    void* source_ = nullptr;

    vtable const* vt_ = nullptr;

    vtable const* vt_ = nullptr;

    void* cached_awaitable_ = nullptr;

    void* cached_awaitable_ = nullptr;

    awaitable_ops const* active_ops_ = nullptr;

    awaitable_ops const* active_ops_ = nullptr;

    read_awaitable_ops const* active_read_ops_ = nullptr;

    read_awaitable_ops const* active_read_ops_ = nullptr;

    void* storage_ = nullptr;

    void* storage_ = nullptr;

public:

public:

    /** Destructor.

    /** Destructor.

        Destroys the owned source (if any) and releases the cached

        Destroys the owned source (if any) and releases the cached

        awaitable storage.

        awaitable storage.

    */

    */

    ~any_buffer_source();

    ~any_buffer_source();

    /** Default constructor.

    /** Default constructor.

        Constructs an empty wrapper. Operations on a default-constructed

        Constructs an empty wrapper. Operations on a default-constructed

        wrapper result in undefined behavior.

        wrapper result in undefined behavior.

    */

    */

    any_buffer_source() = default;

    any_buffer_source() = default;

    /** Non-copyable.

    /** Non-copyable.

        The awaitable cache is per-instance and cannot be shared.

        The awaitable cache is per-instance and cannot be shared.

    */

    */

    any_buffer_source(any_buffer_source const&) = delete;

    any_buffer_source(any_buffer_source const&) = delete;

    any_buffer_source& operator=(any_buffer_source const&) = delete;

    any_buffer_source& operator=(any_buffer_source const&) = delete;

    /** Move constructor.

    /** Move constructor.

        Transfers ownership of the wrapped source (if owned) and

        Transfers ownership of the wrapped source (if owned) and

        cached awaitable storage from `other`. After the move, `other` is

        cached awaitable storage from `other`. After the move, `other` is

        in a default-constructed state.

        in a default-constructed state.

        @param other The wrapper to move from.

        @param other The wrapper to move from.

    */

    */

    {

    {

    /** Move assignment operator.

    /** Move assignment operator.

        Destroys any owned source and releases existing resources,

        Destroys any owned source and releases existing resources,

        then transfers ownership from `other`.

        then transfers ownership from `other`.

        @param other The wrapper to move from.

        @param other The wrapper to move from.

        @return Reference to this wrapper.

        @return Reference to this wrapper.

    */

    */

    any_buffer_source&

    any_buffer_source&

    operator=(any_buffer_source&& other) noexcept;

    operator=(any_buffer_source&& other) noexcept;

    /** Construct by taking ownership of a BufferSource.

    /** Construct by taking ownership of a BufferSource.

        Allocates storage and moves the source into this wrapper.

        Allocates storage and moves the source into this wrapper.

        The wrapper owns the source and will destroy it. If `S` also

        The wrapper owns the source and will destroy it. If `S` also

        satisfies @ref ReadSource, native read operations are

        satisfies @ref ReadSource, native read operations are

        forwarded through the virtual boundary.

        forwarded through the virtual boundary.

        @param s The source to take ownership of.

        @param s The source to take ownership of.

    */

    */

    template<BufferSource S>

    template<BufferSource S>

        requires (!std::same_as<std::decay_t<S>, any_buffer_source>)

        requires (!std::same_as<std::decay_t<S>, any_buffer_source>)

    any_buffer_source(S s);

    any_buffer_source(S s);

    /** Construct by wrapping a BufferSource without ownership.

    /** Construct by wrapping a BufferSource without ownership.

        Wraps the given source by pointer. The source must remain

        Wraps the given source by pointer. The source must remain

        valid for the lifetime of this wrapper. If `S` also

        valid for the lifetime of this wrapper. If `S` also

        satisfies @ref ReadSource, native read operations are

        satisfies @ref ReadSource, native read operations are

        forwarded through the virtual boundary.

        forwarded through the virtual boundary.

        @param s Pointer to the source to wrap.

        @param s Pointer to the source to wrap.

    */

    */

    template<BufferSource S>

    template<BufferSource S>

    any_buffer_source(S* s);

    any_buffer_source(S* s);

    /** Check if the wrapper contains a valid source.

    /** Check if the wrapper contains a valid source.

        @return `true` if wrapping a source, `false` if default-constructed

        @return `true` if wrapping a source, `false` if default-constructed

            or moved-from.

            or moved-from.

    */

    */

    bool

    bool

    {

    {

    }

    }

    /** Check if the wrapper contains a valid source.

    /** Check if the wrapper contains a valid source.

        @return `true` if wrapping a source, `false` if default-constructed

        @return `true` if wrapping a source, `false` if default-constructed

            or moved-from.

            or moved-from.

    */

    */

    explicit

    explicit

    {

    {

    }

    }

    /** Consume bytes from the source.

    /** Consume bytes from the source.

        Advances the internal read position of the underlying source

        Advances the internal read position of the underlying source

        by the specified number of bytes. The next call to @ref pull

        by the specified number of bytes. The next call to @ref pull

        returns data starting after the consumed bytes.

        returns data starting after the consumed bytes.

        @param n The number of bytes to consume. Must not exceed the

        @param n The number of bytes to consume. Must not exceed the

        total size of buffers returned by the previous @ref pull.

        total size of buffers returned by the previous @ref pull.

        @par Preconditions

        @par Preconditions

        The wrapper must contain a valid source (`has_value() == true`).

        The wrapper must contain a valid source (`has_value() == true`).

    */

    */

    void

    void

    consume(std::size_t n) noexcept;

    consume(std::size_t n) noexcept;

    /** Pull buffer data from the source.

    /** Pull buffer data from the source.

        Fills the provided span with buffer descriptors from the

        Fills the provided span with buffer descriptors from the

        underlying source. The operation completes when data is

        underlying source. The operation completes when data is

        available, the source is exhausted, or an error occurs.

        available, the source is exhausted, or an error occurs.

        @param dest Span of const_buffer to fill.

        @param dest Span of const_buffer to fill.

        @return An awaitable yielding `(error_code,std::span<const_buffer>)`.

        @return An awaitable yielding `(error_code,std::span<const_buffer>)`.

            On success with data, a non-empty span of filled buffers.

            On success with data, a non-empty span of filled buffers.

            On EOF, `ec == cond::eof` and span is empty.

            On EOF, `ec == cond::eof` and span is empty.

        @par Preconditions

        @par Preconditions

        The wrapper must contain a valid source (`has_value() == true`).

        The wrapper must contain a valid source (`has_value() == true`).

        The caller must not call this function again after a prior

        The caller must not call this function again after a prior

        call returned an error.

        call returned an error.

    */

    */

    auto

    auto

    pull(std::span<const_buffer> dest);

    pull(std::span<const_buffer> dest);

    /** Read some data into a mutable buffer sequence.

    /** Read some data into a mutable buffer sequence.

        Reads one or more bytes into the caller's buffers. May fill

        Reads one or more bytes into the caller's buffers. May fill

        less than the full sequence.

        less than the full sequence.

        When the wrapped type provides native @ref ReadSource support,

        When the wrapped type provides native @ref ReadSource support,

        the operation forwards directly. Otherwise it is synthesized

        the operation forwards directly. Otherwise it is synthesized

        from @ref pull, @ref buffer_copy, and @ref consume.

        from @ref pull, @ref buffer_copy, and @ref consume.

        @param buffers The buffer sequence to fill.

        @param buffers The buffer sequence to fill.

        @return An awaitable yielding `(error_code,std::size_t)`.

        @return An awaitable yielding `(error_code,std::size_t)`.

        @par Preconditions

        @par Preconditions

        The wrapper must contain a valid source (`has_value() == true`).

        The wrapper must contain a valid source (`has_value() == true`).

        The caller must not call this function again after a prior

        The caller must not call this function again after a prior

        call returned an error (including EOF).

        call returned an error (including EOF).

        @see pull, consume

        @see pull, consume

    */

    */

    template<MutableBufferSequence MB>

    template<MutableBufferSequence MB>

    io_task<std::size_t>

    io_task<std::size_t>

    read_some(MB buffers);

    read_some(MB buffers);

    /** Read data into a mutable buffer sequence.

    /** Read data into a mutable buffer sequence.

        Fills the provided buffer sequence completely. When the

        Fills the provided buffer sequence completely. When the

        wrapped type provides native @ref ReadSource support, each

        wrapped type provides native @ref ReadSource support, each

        window is forwarded directly. Otherwise the data is

        window is forwarded directly. Otherwise the data is

        synthesized from @ref pull, @ref buffer_copy, and @ref consume.

        synthesized from @ref pull, @ref buffer_copy, and @ref consume.

        @param buffers The buffer sequence to fill.

        @param buffers The buffer sequence to fill.

        @return An awaitable yielding `(error_code,std::size_t)`.

        @return An awaitable yielding `(error_code,std::size_t)`.

            On success, `n == buffer_size(buffers)`.

            On success, `n == buffer_size(buffers)`.

            On EOF, `ec == error::eof` and `n` is bytes transferred.

            On EOF, `ec == error::eof` and `n` is bytes transferred.

        @par Preconditions

        @par Preconditions

        The wrapper must contain a valid source (`has_value() == true`).

        The wrapper must contain a valid source (`has_value() == true`).

        The caller must not call this function again after a prior

        The caller must not call this function again after a prior

        call returned an error (including EOF).

        call returned an error (including EOF).

        @see pull, consume

        @see pull, consume

    */

    */

    template<MutableBufferSequence MB>

    template<MutableBufferSequence MB>

    io_task<std::size_t>

    io_task<std::size_t>

    read(MB buffers);

    read(MB buffers);

protected:

protected:

    /** Rebind to a new source after move.

    /** Rebind to a new source after move.

        Updates the internal pointer to reference a new source object.

        Updates the internal pointer to reference a new source object.

        Used by owning wrappers after move assignment when the owned

        Used by owning wrappers after move assignment when the owned

        object has moved to a new location.

        object has moved to a new location.

        @param new_source The new source to bind to. Must be the same

        @param new_source The new source to bind to. Must be the same

            type as the original source.

            type as the original source.

        @note Terminates if called with a source of different type

        @note Terminates if called with a source of different type

            than the original.

            than the original.

    */

    */

    template<BufferSource S>

    template<BufferSource S>

    void

    void

    rebind(S& new_source) noexcept

    rebind(S& new_source) noexcept

    {

    {

        if(vt_ != &vtable_for_impl<S>::value)

        if(vt_ != &vtable_for_impl<S>::value)

            std::terminate();

            std::terminate();

        source_ = &new_source;

        source_ = &new_source;

    }

    }

private:

private:

    /** Forward a partial read through the vtable.

    /** Forward a partial read through the vtable.

        Constructs the underlying `read_some` awaitable in

        Constructs the underlying `read_some` awaitable in

        cached storage and returns a type-erased awaitable.

        cached storage and returns a type-erased awaitable.

    */

    */

    auto

    auto

    read_some_(std::span<mutable_buffer const> buffers);

    read_some_(std::span<mutable_buffer const> buffers);

    /** Forward a complete read through the vtable.

    /** Forward a complete read through the vtable.

        Constructs the underlying `read` awaitable in

        Constructs the underlying `read` awaitable in

        cached storage and returns a type-erased awaitable.

        cached storage and returns a type-erased awaitable.

    */

    */

    auto

    auto

    read_(std::span<mutable_buffer const> buffers);

    read_(std::span<mutable_buffer const> buffers);

};

};

//----------------------------------------------------------

//----------------------------------------------------------

/** Type-erased ops for awaitables yielding `io_result<std::span<const_buffer>>`. */

/** Type-erased ops for awaitables yielding `io_result<std::span<const_buffer>>`. */

struct any_buffer_source::awaitable_ops

struct any_buffer_source::awaitable_ops

{

{

    bool (*await_ready)(void*);

    bool (*await_ready)(void*);

    coro (*await_suspend)(void*, coro, executor_ref, std::stop_token);

    coro (*await_suspend)(void*, coro, executor_ref const&, std::stop_token const&);

    io_result<std::span<const_buffer>> (*await_resume)(void*);

    io_result<std::span<const_buffer>> (*await_resume)(void*);

    void (*destroy)(void*) noexcept;

    void (*destroy)(void*) noexcept;

};

};

/** Type-erased ops for awaitables yielding `io_result<std::size_t>`. */

/** Type-erased ops for awaitables yielding `io_result<std::size_t>`. */

struct any_buffer_source::read_awaitable_ops

struct any_buffer_source::read_awaitable_ops

{

{

    bool (*await_ready)(void*);

    bool (*await_ready)(void*);

    coro (*await_suspend)(void*, coro, executor_ref, std::stop_token);

    coro (*await_suspend)(void*, coro, executor_ref const&, std::stop_token const&);

    io_result<std::size_t> (*await_resume)(void*);

    io_result<std::size_t> (*await_resume)(void*);

    void (*destroy)(void*) noexcept;

    void (*destroy)(void*) noexcept;

};

};

struct any_buffer_source::vtable

struct any_buffer_source::vtable

{

{

    // BufferSource ops (always populated)

    // BufferSource ops (always populated)

    void (*destroy)(void*) noexcept;

    void (*destroy)(void*) noexcept;

    void (*do_consume)(void* source, std::size_t n) noexcept;

    void (*do_consume)(void* source, std::size_t n) noexcept;

    std::size_t awaitable_size;

    std::size_t awaitable_size;

    std::size_t awaitable_align;

    std::size_t awaitable_align;

    awaitable_ops const* (*construct_awaitable)(

    awaitable_ops const* (*construct_awaitable)(

        void* source,

        void* source,

        void* storage,

        void* storage,

        std::span<const_buffer> dest);

        std::span<const_buffer> dest);

    // ReadSource forwarding (null when wrapped type is BufferSource-only)

    // ReadSource forwarding (null when wrapped type is BufferSource-only)

    read_awaitable_ops const* (*construct_read_some_awaitable)(

    read_awaitable_ops const* (*construct_read_some_awaitable)(

        void* source,

        void* source,

        void* storage,

        void* storage,

        std::span<mutable_buffer const> buffers);

        std::span<mutable_buffer const> buffers);

    read_awaitable_ops const* (*construct_read_awaitable)(

    read_awaitable_ops const* (*construct_read_awaitable)(

        void* source,

        void* source,

        void* storage,

        void* storage,

        std::span<mutable_buffer const> buffers);

        std::span<mutable_buffer const> buffers);

};

};

template<BufferSource S>

template<BufferSource S>

struct any_buffer_source::vtable_for_impl

struct any_buffer_source::vtable_for_impl

{

{

    using PullAwaitable = decltype(std::declval<S&>().pull(

    using PullAwaitable = decltype(std::declval<S&>().pull(

        std::declval<std::span<const_buffer>>()));

        std::declval<std::span<const_buffer>>()));

    static void

    static void

    {

    {

    static void

    static void

    {

    {

    static awaitable_ops const*

    static awaitable_ops const*

        void* source,

        void* source,

        void* storage,

        void* storage,

        std::span<const_buffer> dest)

        std::span<const_buffer> dest)

    {

    {

        static constexpr awaitable_ops ops = {

        static constexpr awaitable_ops ops = {

            },

            },

            },

            },

            },

            },

            }

            }

        };

        };

    }

    }

    //------------------------------------------------------

    //------------------------------------------------------

    // ReadSource forwarding (only instantiated when ReadSource<S>)

    // ReadSource forwarding (only instantiated when ReadSource<S>)

    static read_awaitable_ops const*

    static read_awaitable_ops const*

        void* source,

        void* source,

        void* storage,

        void* storage,

        std::span<mutable_buffer const> buffers)

        std::span<mutable_buffer const> buffers)

        requires ReadSource<S>

        requires ReadSource<S>

    {

    {

        using Aw = decltype(std::declval<S&>().read_some(

        using Aw = decltype(std::declval<S&>().read_some(

            std::span<mutable_buffer const>{}));

            std::span<mutable_buffer const>{}));

        static constexpr read_awaitable_ops ops = {

        static constexpr read_awaitable_ops ops = {

            },

            },

            },

            },

            },

            },

            }

            }

        };

        };

    }

    }

    static read_awaitable_ops const*

    static read_awaitable_ops const*

        void* source,

        void* source,

        void* storage,

        void* storage,

        std::span<mutable_buffer const> buffers)

        std::span<mutable_buffer const> buffers)

        requires ReadSource<S>

        requires ReadSource<S>

    {

    {

        using Aw = decltype(std::declval<S&>().read(

        using Aw = decltype(std::declval<S&>().read(

            std::span<mutable_buffer const>{}));

            std::span<mutable_buffer const>{}));

        static constexpr read_awaitable_ops ops = {

        static constexpr read_awaitable_ops ops = {

            },

            },

            },

            },

            },

            },

            }

            }

        };

        };

    }

    }

    //------------------------------------------------------

    //------------------------------------------------------

    static consteval std::size_t

    static consteval std::size_t

    compute_max_size() noexcept

    compute_max_size() noexcept

    {

    {

        std::size_t s = sizeof(PullAwaitable);

        std::size_t s = sizeof(PullAwaitable);

        if constexpr (ReadSource<S>)

        if constexpr (ReadSource<S>)

        {

        {

            using RS = decltype(std::declval<S&>().read_some(

            using RS = decltype(std::declval<S&>().read_some(

                std::span<mutable_buffer const>{}));

                std::span<mutable_buffer const>{}));

            using R = decltype(std::declval<S&>().read(

            using R = decltype(std::declval<S&>().read(

                std::span<mutable_buffer const>{}));

                std::span<mutable_buffer const>{}));

            if(sizeof(RS) > s) s = sizeof(RS);

            if(sizeof(RS) > s) s = sizeof(RS);

            if(sizeof(R) > s) s = sizeof(R);

            if(sizeof(R) > s) s = sizeof(R);

        }

        }

        return s;

        return s;

    }

    }

    static consteval std::size_t

    static consteval std::size_t

    compute_max_align() noexcept

    compute_max_align() noexcept

    {

    {

        std::size_t a = alignof(PullAwaitable);

        std::size_t a = alignof(PullAwaitable);

        if constexpr (ReadSource<S>)

        if constexpr (ReadSource<S>)

        {

        {

            using RS = decltype(std::declval<S&>().read_some(

            using RS = decltype(std::declval<S&>().read_some(

                std::span<mutable_buffer const>{}));

                std::span<mutable_buffer const>{}));

            using R = decltype(std::declval<S&>().read(

            using R = decltype(std::declval<S&>().read(

                std::span<mutable_buffer const>{}));

                std::span<mutable_buffer const>{}));

            if(alignof(RS) > a) a = alignof(RS);

            if(alignof(RS) > a) a = alignof(RS);

            if(alignof(R) > a) a = alignof(R);

            if(alignof(R) > a) a = alignof(R);

        }

        }

        return a;

        return a;

    }

    }

    static consteval vtable

    static consteval vtable

    make_vtable() noexcept

    make_vtable() noexcept

    {

    {

        vtable v{};

        vtable v{};

        v.destroy = &do_destroy_impl;

        v.destroy = &do_destroy_impl;

        v.do_consume = &do_consume_impl;

        v.do_consume = &do_consume_impl;

        v.awaitable_size = compute_max_size();

        v.awaitable_size = compute_max_size();

        v.awaitable_align = compute_max_align();

        v.awaitable_align = compute_max_align();

        v.construct_awaitable = &construct_awaitable_impl;

        v.construct_awaitable = &construct_awaitable_impl;

        v.construct_read_some_awaitable = nullptr;

        v.construct_read_some_awaitable = nullptr;