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_SINK_HPP

#ifndef BOOST_CAPY_IO_ANY_WRITE_SINK_HPP

#define BOOST_CAPY_IO_ANY_WRITE_SINK_HPP

#define BOOST_CAPY_IO_ANY_WRITE_SINK_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_sink.hpp>

#include <boost/capy/concept/write_sink.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 <boost/capy/task.hpp>

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

/** Type-erased wrapper for any WriteSink.

    This class provides type erasure for any type satisfying the

    This class provides type erasure for any type satisfying the

    @ref WriteSink concept, enabling runtime polymorphism for

    @ref WriteSink concept, enabling runtime polymorphism for

    sink write operations. It uses cached awaitable storage to achieve

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

      allocates storage and owns the sink.

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

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

      pointed-to sink must outlive this wrapper.

      pointed-to sink 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 sink

    // Owning - takes ownership of the sink

    any_write_sink ws(some_sink{args...});

    any_write_sink ws(some_sink{args...});

    // Reference - wraps without ownership

    // Reference - wraps without ownership

    some_sink sink;

    some_sink sink;

    any_write_sink ws(&sink);

    any_write_sink ws(&sink);

    const_buffer buf(data, size);

    const_buffer buf(data, size);

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

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

    auto [ec2] = co_await ws.write_eof();

    auto [ec2] = co_await ws.write_eof();

    @endcode

    @endcode

    @see any_write_stream, WriteSink

    @see any_write_stream, WriteSink

*/

*/

class any_write_sink

class any_write_sink

{

{

    struct vtable;

    struct vtable;

    struct write_awaitable_ops;

    struct write_awaitable_ops;

    struct eof_awaitable_ops;

    struct eof_awaitable_ops;

    template<WriteSink S>

    template<WriteSink S>

    struct vtable_for_impl;

    struct vtable_for_impl;

    void* sink_ = nullptr;

    void* sink_ = nullptr;

    vtable const* vt_ = nullptr;

    vtable const* vt_ = nullptr;

    void* cached_awaitable_ = nullptr;

    void* cached_awaitable_ = nullptr;

    void* storage_ = nullptr;

    void* storage_ = nullptr;

    write_awaitable_ops const* active_write_ops_ = nullptr;

    write_awaitable_ops const* active_write_ops_ = nullptr;

    eof_awaitable_ops const* active_eof_ops_ = nullptr;

    eof_awaitable_ops const* active_eof_ops_ = nullptr;

public:

public:

    /** Destructor.

    /** Destructor.

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

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

        awaitable storage.

        awaitable storage.

    */

    */

    ~any_write_sink();

    ~any_write_sink();

    /** 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_write_sink() = default;

    any_write_sink() = 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_write_sink(any_write_sink const&) = delete;

    any_write_sink(any_write_sink const&) = delete;

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

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

    /** Move constructor.

    /** Move constructor.

        Transfers ownership of the wrapped sink (if owned) and

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

        Destroys any owned sink 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_sink&

    any_write_sink&

    operator=(any_write_sink&& other) noexcept;

    operator=(any_write_sink&& other) noexcept;

    /** Construct by taking ownership of a WriteSink.

    /** Construct by taking ownership of a WriteSink.

        Allocates storage and moves the sink into this wrapper.

        Allocates storage and moves the sink into this wrapper.

        The wrapper owns the sink and will destroy it.

        The wrapper owns the sink and will destroy it.

        @param s The sink to take ownership of.

        @param s The sink to take ownership of.

    */

    */

    template<WriteSink S>

    template<WriteSink S>

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

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

    any_write_sink(S s);

    any_write_sink(S s);

    /** Construct by wrapping a WriteSink without ownership.

    /** Construct by wrapping a WriteSink without ownership.

        Wraps the given sink by pointer. The sink must remain

        Wraps the given sink by pointer. The sink must remain

        valid for the lifetime of this wrapper.

        valid for the lifetime of this wrapper.

        @param s Pointer to the sink to wrap.

        @param s Pointer to the sink to wrap.

    */

    */

    template<WriteSink S>

    template<WriteSink S>

    any_write_sink(S* s);

    any_write_sink(S* s);

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

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

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

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

            or moved-from.

            or moved-from.

    */

    */

    bool

    bool

    {

    {

    }

    }

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

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

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

        @return `true` if wrapping a sink, `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 all bytes have been consumed, or an error

        completes when all bytes have been consumed, 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 sink (`has_value() == true`).

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

    */

    */

    template<ConstBufferSequence CB>

    template<ConstBufferSequence CB>

    task<io_result<std::size_t>>

    task<io_result<std::size_t>>

    write(CB buffers);

    write(CB buffers);

    /** Initiate an asynchronous write operation with optional EOF.

    /** Initiate an asynchronous write operation with optional EOF.

        Writes data from the provided buffer sequence, optionally

        Writes data from the provided buffer sequence, optionally

        finalizing the sink afterwards. The operation completes when

        finalizing the sink afterwards. The operation completes when

        all bytes have been consumed and (if eof is true) the sink

        all bytes have been consumed and (if eof is true) the sink

        is finalized, or an error occurs.

        is finalized, or an error 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.

        @param eof If `true`, the sink is finalized after writing

        @param eof If `true`, the sink is finalized after writing

            the data.

            the data.

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

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

    */

    */

    template<ConstBufferSequence CB>

    template<ConstBufferSequence CB>

    task<io_result<std::size_t>>

    task<io_result<std::size_t>>

    write(CB buffers, bool eof);

    write(CB buffers, bool eof);

    /** Signal end of data.

    /** Signal end of data.

        Indicates that no more data will be written to the sink.

        Indicates that no more data will be written to the sink.

        The operation completes when the sink is finalized, or

        The operation completes when the sink is finalized, or

        an error occurs.

        an error occurs.

        @return An awaitable yielding `(error_code)`.

        @return An awaitable yielding `(error_code)`.

        @par Preconditions

        @par Preconditions

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

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

    */

    */

    auto

    auto

    write_eof();

    write_eof();

protected:

protected:

    /** Rebind to a new sink after move.

    /** Rebind to a new sink after move.

        Updates the internal pointer to reference a new sink object.

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

        @param new_sink The new sink to bind to. Must be the same

            type as the original sink.

            type as the original sink.

        @note Terminates if called with a sink of different type

        @note Terminates if called with a sink of different type

            than the original.

            than the original.

    */

    */

    template<WriteSink S>

    template<WriteSink S>

    void

    void

    rebind(S& new_sink) noexcept

    rebind(S& new_sink) noexcept

    {

    {

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

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

            std::terminate();

            std::terminate();

        sink_ = &new_sink;

        sink_ = &new_sink;

    }

    }

private:

private:

    auto

    auto

    write_some_(std::span<const_buffer const> buffers, bool eof);

    write_some_(std::span<const_buffer const> buffers, bool eof);

};

};

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

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

struct any_write_sink::write_awaitable_ops

struct any_write_sink::write_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_sink::eof_awaitable_ops

struct any_write_sink::eof_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<> (*await_resume)(void*);

    io_result<> (*await_resume)(void*);

    void (*destroy)(void*) noexcept;

    void (*destroy)(void*) noexcept;

};

};

struct any_write_sink::vtable

struct any_write_sink::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;

    write_awaitable_ops const* (*construct_write_awaitable)(

    write_awaitable_ops const* (*construct_write_awaitable)(

        void* sink,

        void* sink,

        void* storage,

        void* storage,

        std::span<const_buffer const> buffers,

        std::span<const_buffer const> buffers,

        bool eof);

        bool eof);

    eof_awaitable_ops const* (*construct_eof_awaitable)(

    eof_awaitable_ops const* (*construct_eof_awaitable)(

        void* sink,

        void* sink,

        void* storage);

        void* storage);

};

};

template<WriteSink S>

template<WriteSink S>

struct any_write_sink::vtable_for_impl

struct any_write_sink::vtable_for_impl

{

{

    using WriteAwaitable = decltype(std::declval<S&>().write(

    using WriteAwaitable = decltype(std::declval<S&>().write(

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

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

    using EofAwaitable = decltype(std::declval<S&>().write_eof());

    using EofAwaitable = decltype(std::declval<S&>().write_eof());

    static void

    static void

    {

    {

    static write_awaitable_ops const*

    static write_awaitable_ops const*

        void* sink,

        void* sink,

        void* storage,

        void* storage,

        std::span<const_buffer const> buffers,

        std::span<const_buffer const> buffers,

        bool eof)

        bool eof)

    {

    {

        static constexpr write_awaitable_ops ops = {

        static constexpr write_awaitable_ops ops = {

            },

            },

            },

            },

            },

            },

            }

            }

        };

        };

    }

    }

    static eof_awaitable_ops const*

    static eof_awaitable_ops const*

        void* sink,

        void* sink,

        void* storage)

        void* storage)

    {

    {

        static constexpr eof_awaitable_ops ops = {

        static constexpr eof_awaitable_ops ops = {

            },

            },

            },

            },

            },

            },

            }

            }

        };

        };

    }

    }

    static constexpr std::size_t max_awaitable_size =

    static constexpr std::size_t max_awaitable_size =

        sizeof(WriteAwaitable) > sizeof(EofAwaitable)

        sizeof(WriteAwaitable) > sizeof(EofAwaitable)

            ? sizeof(WriteAwaitable)

            ? sizeof(WriteAwaitable)

            : sizeof(EofAwaitable);

            : sizeof(EofAwaitable);

    static constexpr std::size_t max_awaitable_align =

    static constexpr std::size_t max_awaitable_align =

        alignof(WriteAwaitable) > alignof(EofAwaitable)

        alignof(WriteAwaitable) > alignof(EofAwaitable)

            ? alignof(WriteAwaitable)

            ? alignof(WriteAwaitable)

            : alignof(EofAwaitable);

            : alignof(EofAwaitable);

    static constexpr vtable value = {

    static constexpr vtable value = {

        &do_destroy_impl,

        &do_destroy_impl,

        max_awaitable_size,

        max_awaitable_size,

        max_awaitable_align,

        max_awaitable_align,

        &construct_write_awaitable_impl,

        &construct_write_awaitable_impl,

        &construct_eof_awaitable_impl

        &construct_eof_awaitable_impl

    };

    };

};

};

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

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

inline

inline

{

{

    {

    {

    }

    }

inline any_write_sink&

inline any_write_sink&

{

{

    {

    {

        {

        {

        }

        }

    }

    }

}

}

template<WriteSink S>

template<WriteSink S>

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

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

any_write_sink::any_write_sink(S s)

any_write_sink::any_write_sink(S s)

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

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

{

{

    struct guard {

    struct guard {

        any_write_sink* self;

        any_write_sink* self;

        bool committed = false;

        bool committed = false;

        ~guard() {

        ~guard() {

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

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

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

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

                ::operator delete(self->storage_);

                ::operator delete(self->storage_);

                self->storage_ = nullptr;

                self->storage_ = nullptr;

                self->sink_ = nullptr;

                self->sink_ = nullptr;

            }

            }

        }

        }

    } g{this};

    } g{this};

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

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

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

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

    // Preallocate the awaitable storage (sized for max of write/eof)

    // Preallocate the awaitable storage (sized for max of write/eof)

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

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

    g.committed = true;

    g.committed = true;

}

}

template<WriteSink S>

template<WriteSink S>

{

{

    // Preallocate the awaitable storage (sized for max of write/eof)

    // Preallocate the awaitable storage (sized for max of write/eof)

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

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

inline auto

inline auto

    std::span<const_buffer const> buffers,

    std::span<const_buffer const> buffers,

    bool eof)

    bool eof)

{

{

    struct awaitable

    struct awaitable

    {

    {

        any_write_sink* self_;

        any_write_sink* self_;

        std::span<const_buffer const> buffers_;

        std::span<const_buffer const> buffers_;

        bool eof_;

        bool eof_;

        bool

        bool

        {

        {

        }

        }

        coro

        coro

        {

        {

            // Construct the underlying awaitable into cached storage

            // Construct the underlying awaitable into cached storage

                buffers_,

                buffers_,

            // 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_sink* self;

                any_write_sink* self;

    };

    };

}

}

inline auto

inline auto

{

{

    struct awaitable

    struct awaitable

    {

    {

        any_write_sink* self_;

        any_write_sink* self_;

        bool

        bool

        {

        {

        }

        }

        coro

        coro

        {

        {

            // Construct the underlying awaitable into cached storage

            // Construct the underlying awaitable into cached storage