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_WRITE_STREAM_HPP

#ifndef BOOST_CAPY_IO_ANY_WRITE_STREAM_HPP

#define BOOST_CAPY_IO_ANY_WRITE_STREAM_HPP

#define BOOST_CAPY_IO_ANY_WRITE_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/write_stream.hpp>

#include <boost/capy/concept/write_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 WriteStream.

/** Type-erased wrapper for any WriteStream.

    This class provides type erasure for any type satisfying the

    This class provides type erasure for any type satisfying the

    @ref WriteStream concept, enabling runtime polymorphism for

    @ref WriteStream concept, enabling runtime polymorphism for

    write operations. It uses cached awaitable storage to achieve

    write 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_write_stream stream(socket{ioc});

    any_write_stream stream(socket{ioc});

    // Reference - wraps without ownership

    // Reference - wraps without ownership

    socket sock(ioc);

    socket sock(ioc);

    any_write_stream stream(&sock);

    any_write_stream stream(&sock);

    const_buffer buf(data, size);

    const_buffer buf(data, size);

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

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

    @endcode

    @endcode

    @see any_read_stream, any_stream, WriteStream

    @see any_read_stream, any_stream, WriteStream

*/

*/

class any_write_stream

class any_write_stream

{

{

    struct vtable;

    struct vtable;

    struct awaitable_ops;

    struct awaitable_ops;

    template<WriteStream S>

    template<WriteStream 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_write_stream();

    ~any_write_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_write_stream(any_write_stream const&) = delete;

    any_write_stream(any_write_stream const&) = delete;

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

    any_write_stream& operator=(any_write_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_write_stream&

    any_write_stream&

    operator=(any_write_stream&& other) noexcept;

    operator=(any_write_stream&& other) noexcept;

    /** Construct by taking ownership of a WriteStream.

    /** Construct by taking ownership of a WriteStream.

        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<WriteStream S>

    template<WriteStream S>

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

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

    any_write_stream(S s);

    any_write_stream(S s);

    /** Construct by wrapping a WriteStream without ownership.

    /** Construct by wrapping a WriteStream 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<WriteStream S>

    template<WriteStream S>

    any_write_stream(S* s);

    any_write_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 write operation.

    /** Initiate an asynchronous write operation.

        Writes data from the provided buffer sequence. The operation

        Writes data from the provided buffer sequence. The operation

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

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

        occurs.

        occurs.

        @param buffers The buffer sequence containing data to write.

        @param buffers The buffer sequence containing data to write.

            Passed by value to ensure the sequence lives in the

            Passed by value to ensure the sequence lives in the

            coroutine frame across suspension points.

            coroutine frame 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<ConstBufferSequence CB>

    template<ConstBufferSequence CB>

    auto

    auto

    write_some(CB buffers);

    write_some(CB 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<WriteStream S>

    template<WriteStream 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_write_stream::awaitable_ops

struct any_write_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_write_stream::vtable

struct any_write_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<const_buffer const> buffers);

        std::span<const_buffer const> buffers);

};

};

template<WriteStream S>

template<WriteStream S>

struct any_write_stream::vtable_for_impl

struct any_write_stream::vtable_for_impl

{

{

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

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

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

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

    static void

    static void

    {

    {

    static awaitable_ops const*

    static awaitable_ops const*

        void* stream,

        void* stream,

        void* storage,

        void* storage,

        std::span<const_buffer const> buffers)

        std::span<const_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_write_stream&

inline any_write_stream&

{

{

    {

    {

        {

        {

        }

        }

    }

    }

}

}

template<WriteStream S>

template<WriteStream S>

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

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

any_write_stream::any_write_stream(S s)

any_write_stream::any_write_stream(S s)

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

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

{

{

    struct guard {

    struct guard {

        any_write_stream* self;

        any_write_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<WriteStream S>

template<WriteStream S>

{

{

    // Preallocate the awaitable storage

    // Preallocate the awaitable storage

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

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

template<ConstBufferSequence CB>

template<ConstBufferSequence CB>

auto

auto

{

{

    struct awaitable

    struct awaitable

    {

    {

        any_write_stream* self_;

        any_write_stream* self_;

        buffer_param<CB> bp_;

        buffer_param<CB> 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_write_stream* self;

                any_write_stream* self;

    };

    };

}

}

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif