Diff coverage report for

//

//

// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot com)

// Copyright (c) 2025 Vinnie Falco (vinnie dot falco at gmail dot 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_READ_STREAM_HPP

#ifndef BOOST_CAPY_IO_ANY_READ_STREAM_HPP

#define BOOST_CAPY_IO_ANY_READ_STREAM_HPP

#define BOOST_CAPY_IO_ANY_READ_STREAM_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_param.hpp>

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

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

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

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

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

#include <boost/capy/coro.hpp>

#include <boost/capy/coro.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 <concepts>

#include <concepts>

#include <coroutine>

#include <coroutine>

#include <cstddef>

#include <cstddef>

#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 ReadStream.

/** Type-erased wrapper for any ReadStream.

    This class provides type erasure for any type satisfying the

    This class provides type erasure for any type satisfying the

    @ref ReadStream concept, enabling runtime polymorphism for

    @ref ReadStream concept, enabling runtime polymorphism for

    read operations. It uses cached awaitable storage to achieve

    read operations. It uses cached awaitable storage to achieve

    zero steady-state allocation after construction.

    zero steady-state allocation after construction.

    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 stream.

      allocates storage and owns the stream.

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

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

      pointed-to stream must outlive this wrapper.

      pointed-to stream must outlive this wrapper.

    @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 stream

    // Owning - takes ownership of the stream

    any_read_stream stream(socket{ioc});

    any_read_stream stream(socket{ioc});

    // Reference - wraps without ownership

    // Reference - wraps without ownership

    socket sock(ioc);

    socket sock(ioc);

    any_read_stream stream(&sock);

    any_read_stream stream(&sock);

    mutable_buffer buf(data, size);

    mutable_buffer buf(data, size);

    auto [ec, n] = co_await stream.read_some(std::span(&buf, 1));

    auto [ec, n] = co_await stream.read_some(std::span(&buf, 1));

    @endcode

    @endcode

    @see any_write_stream, any_stream, ReadStream

    @see any_write_stream, any_stream, ReadStream

*/

*/

class any_read_stream

class any_read_stream

{

{

    struct vtable;

    struct vtable;

    struct awaitable_ops;

    struct awaitable_ops;

    template<ReadStream S>

    template<ReadStream S>

    struct vtable_for_impl;

    struct vtable_for_impl;

    void* stream_ = nullptr;

    void* stream_ = nullptr;

    vtable const* vt_ = nullptr;

    vtable const* vt_ = nullptr;

    void* cached_awaitable_ = nullptr;

    void* cached_awaitable_ = nullptr;

    void* storage_ = nullptr;

    void* storage_ = nullptr;

    awaitable_ops const* active_ops_ = nullptr;

    awaitable_ops const* active_ops_ = nullptr;

public:

public:

    /** Destructor.

    /** Destructor.

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

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

        awaitable storage.

        awaitable storage.

    */

    */

    ~any_read_stream();

    ~any_read_stream();

    /** 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.

    */

    */

    /** 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_read_stream(any_read_stream const&) = delete;

    any_read_stream(any_read_stream const&) = delete;

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

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

    /** Move constructor.

    /** Move constructor.

        Transfers ownership of the wrapped stream (if owned) and

        Transfers ownership of the wrapped stream (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 stream and releases existing resources,

        Destroys any owned stream 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_read_stream&

    any_read_stream&

    operator=(any_read_stream&& other) noexcept;

    operator=(any_read_stream&& other) noexcept;

    /** Construct by taking ownership of a ReadStream.

    /** Construct by taking ownership of a ReadStream.

        Allocates storage and moves the stream into this wrapper.

        Allocates storage and moves the stream into this wrapper.

        The wrapper owns the stream and will destroy it.

        The wrapper owns the stream and will destroy it.

        @param s The stream to take ownership of.

        @param s The stream to take ownership of.

    */

    */

    template<ReadStream S>

    template<ReadStream S>

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

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

    any_read_stream(S s);

    any_read_stream(S s);

    /** Construct by wrapping a ReadStream without ownership.

    /** Construct by wrapping a ReadStream without ownership.

        Wraps the given stream by pointer. The stream must remain

        Wraps the given stream by pointer. The stream must remain

        valid for the lifetime of this wrapper.

        valid for the lifetime of this wrapper.

        @param s Pointer to the stream to wrap.

        @param s Pointer to the stream to wrap.

    */

    */

    template<ReadStream S>

    template<ReadStream S>

    any_read_stream(S* s);

    any_read_stream(S* s);

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

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

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

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

            or moved-from.

            or moved-from.

    */

    */

    bool

    bool

    {

    {

    }

    }

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

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

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

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

            or moved-from.

            or moved-from.

    */

    */

    explicit

    explicit

    {

    {

    }

    }

    /** Initiate an asynchronous read operation.

    /** Initiate an asynchronous read operation.

        Reads data into the provided buffer sequence. The operation

        Reads data into the provided buffer sequence. The operation

        completes when at least one byte has been read, or an error

        completes when at least one byte has been read, or an error

        occurs.

        occurs.

        @param buffers The buffer sequence to read into. Passed by

        @param buffers The buffer sequence to read into. Passed by

            value to ensure the sequence lives in the coroutine frame

            value to ensure the sequence lives in the coroutine frame

            across suspension points.

            across suspension points.

        @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 stream (`has_value() == true`).

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

    */

    */

    template<MutableBufferSequence MB>

    template<MutableBufferSequence MB>

    auto

    auto

    read_some(MB buffers);

    read_some(MB buffers);

protected:

protected:

    /** Rebind to a new stream after move.

    /** Rebind to a new stream after move.

        Updates the internal pointer to reference a new stream object.

        Updates the internal pointer to reference a new stream 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_stream The new stream to bind to. Must be the same

        @param new_stream The new stream to bind to. Must be the same

            type as the original stream.

            type as the original stream.

        @note Terminates if called with a stream of different type

        @note Terminates if called with a stream of different type

            than the original.

            than the original.

    */

    */

    template<ReadStream S>

    template<ReadStream S>

    void

    void

    rebind(S& new_stream) noexcept

    rebind(S& new_stream) noexcept

    {

    {

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

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

            std::terminate();

            std::terminate();

        stream_ = &new_stream;

        stream_ = &new_stream;

    }

    }

};

};

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

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

struct any_read_stream::awaitable_ops

struct any_read_stream::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, std::stop_token);

    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_read_stream::vtable

struct any_read_stream::vtable

{

{

    void (*destroy)(void*) noexcept;

    void (*destroy)(void*) 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* stream,

        void* stream,

        void* storage,

        void* storage,

        std::span<mutable_buffer const> buffers);

        std::span<mutable_buffer const> buffers);

};

};

template<ReadStream S>

template<ReadStream S>

struct any_read_stream::vtable_for_impl

struct any_read_stream::vtable_for_impl

{

{

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

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

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

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

    static void

    static void

    {

    {

    static awaitable_ops const*

    static awaitable_ops const*

        void* stream,

        void* stream,

        void* storage,

        void* storage,

        std::span<mutable_buffer const> buffers)

        std::span<mutable_buffer const> buffers)

    {

    {

        static constexpr awaitable_ops ops = {

        static constexpr awaitable_ops ops = {

            },

            },

            },

            },

            },

            },

            }

            }

        };

        };

    }

    }

    static constexpr vtable value = {

    static constexpr vtable value = {

        &do_destroy_impl,

        &do_destroy_impl,

        sizeof(Awaitable),

        sizeof(Awaitable),

        alignof(Awaitable),

        alignof(Awaitable),

        &construct_awaitable_impl

        &construct_awaitable_impl

    };

    };

};

};

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

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

inline

inline

{

{

    {

    {

    }

    }

inline any_read_stream&

inline any_read_stream&

{

{

    {

    {

        {

        {

        }

        }

    }

    }

}

}

template<ReadStream S>

template<ReadStream S>

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

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

any_read_stream::any_read_stream(S s)

any_read_stream::any_read_stream(S s)

    : vt_(&vtable_for_impl<S>::value)

    : vt_(&vtable_for_impl<S>::value)

{

{

    struct guard {

    struct guard {

        any_read_stream* self;

        any_read_stream* self;

        bool committed = false;

        bool committed = false;

        ~guard() {

        ~guard() {

            if(!committed && self->storage_) {

            if(!committed && self->storage_) {

                self->vt_->destroy(self->stream_);

                self->vt_->destroy(self->stream_);

                ::operator delete(self->storage_);

                ::operator delete(self->storage_);

                self->storage_ = nullptr;

                self->storage_ = nullptr;

                self->stream_ = nullptr;

                self->stream_ = nullptr;

            }

            }

        }

        }

    } g{this};

    } g{this};

    storage_ = ::operator new(sizeof(S));

    storage_ = ::operator new(sizeof(S));

    stream_ = ::new(storage_) S(std::move(s));

    stream_ = ::new(storage_) S(std::move(s));

    // Preallocate the awaitable storage

    // Preallocate the awaitable storage

    cached_awaitable_ = ::operator new(vt_->awaitable_size);

    cached_awaitable_ = ::operator new(vt_->awaitable_size);

    g.committed = true;

    g.committed = true;

}

}

template<ReadStream S>

template<ReadStream S>

{

{

    // Preallocate the awaitable storage

    // Preallocate the awaitable storage

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

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

template<MutableBufferSequence MB>

template<MutableBufferSequence MB>

auto

auto

{

{

    struct awaitable

    struct awaitable

    {

    {

        any_read_stream* self_;

        any_read_stream* self_;

        buffer_param<MB> bp_;

        buffer_param<MB> bp_;

        bool

        bool

        {

        {

        }

        }

        coro

        coro

        {

        {

            // Construct the underlying awaitable into cached storage

            // Construct the underlying awaitable into cached storage

            // Check if underlying is immediately ready

            // Check if underlying is immediately ready

            // Forward to underlying awaitable

            // Forward to underlying awaitable

        }

        }

        io_result<std::size_t>

        io_result<std::size_t>

        {

        {

            struct guard {

            struct guard {

                any_read_stream* self;

                any_read_stream* self;

    };

    };

}

}

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif