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_WRITE_NOW_HPP

#ifndef BOOST_CAPY_IO_WRITE_NOW_HPP

#define BOOST_CAPY_IO_WRITE_NOW_HPP

#define BOOST_CAPY_IO_WRITE_NOW_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/consuming_buffers.hpp>

#include <boost/capy/buffers/consuming_buffers.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 <coroutine>

#include <coroutine>

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

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

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

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

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_result.hpp>

#include <cstddef>

#include <cstddef>

#include <exception>

#include <exception>

#include <new>

#include <new>

#include <stop_token>

#include <stop_token>

#include <utility>

#include <utility>

#ifndef BOOST_CAPY_WRITE_NOW_WORKAROUND

#ifndef BOOST_CAPY_WRITE_NOW_WORKAROUND

# if defined(__GNUC__) && !defined(__clang__)

# if defined(__GNUC__) && !defined(__clang__)

#  define BOOST_CAPY_WRITE_NOW_WORKAROUND 1

#  define BOOST_CAPY_WRITE_NOW_WORKAROUND 1

# else

# else

#  define BOOST_CAPY_WRITE_NOW_WORKAROUND 0

#  define BOOST_CAPY_WRITE_NOW_WORKAROUND 0

# endif

# endif

#endif

#endif

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** Eagerly writes complete buffer sequences with frame caching.

/** Eagerly writes complete buffer sequences with frame caching.

    This class wraps a @ref WriteStream and provides an `operator()`

    This class wraps a @ref WriteStream and provides an `operator()`

    that writes an entire buffer sequence, attempting to complete

    that writes an entire buffer sequence, attempting to complete

    synchronously. If every `write_some` completes without suspending,

    synchronously. If every `write_some` completes without suspending,

    the entire operation finishes in `await_ready` with no coroutine

    the entire operation finishes in `await_ready` with no coroutine

    suspension.

    suspension.

    The class maintains a one-element coroutine frame cache. After

    The class maintains a one-element coroutine frame cache. After

    the first call, subsequent calls reuse the cached frame memory,

    the first call, subsequent calls reuse the cached frame memory,

    avoiding repeated allocation for the internal coroutine.

    avoiding repeated allocation for the internal coroutine.

    @tparam Stream The stream type, must satisfy @ref WriteStream.

    @tparam Stream The stream type, must satisfy @ref WriteStream.

    @par Thread Safety

    @par Thread Safety

    Distinct objects: Safe.

    Distinct objects: Safe.

    Shared objects: Unsafe.

    Shared objects: Unsafe.

    @par Preconditions

    @par Preconditions

    Only one operation may be outstanding at a time. A new call to

    Only one operation may be outstanding at a time. A new call to

    `operator()` must not be made until the previous operation has

    `operator()` must not be made until the previous operation has

    completed (i.e., the returned awaitable has been fully consumed).

    completed (i.e., the returned awaitable has been fully consumed).

    @par Example

    @par Example

    @code

    @code

    template< WriteStream Stream >

    template< WriteStream Stream >

    task<> send_messages( Stream& stream )

    task<> send_messages( Stream& stream )

    {

    {

        write_now wn( stream );

        write_now wn( stream );

        auto [ec1, n1] = co_await wn( make_buffer( "hello" ) );

        auto [ec1, n1] = co_await wn( make_buffer( "hello" ) );

        if( ec1 )

        if( ec1 )

            detail::throw_system_error( ec1 );

            detail::throw_system_error( ec1 );

        auto [ec2, n2] = co_await wn( make_buffer( "world" ) );

        auto [ec2, n2] = co_await wn( make_buffer( "world" ) );

        if( ec2 )

        if( ec2 )

            detail::throw_system_error( ec2 );

            detail::throw_system_error( ec2 );

    }

    }

    @endcode

    @endcode

    @see write, write_some, WriteStream, ConstBufferSequence

    @see write, write_some, WriteStream, ConstBufferSequence

*/

*/

template<class Stream>

template<class Stream>

    requires WriteStream<Stream>

    requires WriteStream<Stream>

class write_now

class write_now

{

{

    Stream& stream_;

    Stream& stream_;

    void* cached_frame_ = nullptr;

    void* cached_frame_ = nullptr;

    std::size_t cached_size_ = 0;

    std::size_t cached_size_ = 0;

    struct [[nodiscard]] BOOST_CAPY_CORO_AWAIT_ELIDABLE

    struct [[nodiscard]] BOOST_CAPY_CORO_AWAIT_ELIDABLE

        op_type

        op_type

    {

    {

        struct promise_type

        struct promise_type

        {

        {

            io_result<std::size_t> result_;

            io_result<std::size_t> result_;

            std::exception_ptr ep_;

            std::exception_ptr ep_;

            std::coroutine_handle<> cont_{nullptr};

            std::coroutine_handle<> cont_{nullptr};

            io_env const* env_ = nullptr;

            io_env const* env_ = nullptr;

            bool done_ = false;

            bool done_ = false;

            {

            {

                return op_type{

                return op_type{

                    std::coroutine_handle<

                    std::coroutine_handle<

            }

            }

            {

            {

#if BOOST_CAPY_WRITE_NOW_WORKAROUND

#if BOOST_CAPY_WRITE_NOW_WORKAROUND

#else

#else

                return std::suspend_never{};

                return std::suspend_never{};

#endif

#endif

            }

            }

            {

            {

                struct awaiter

                struct awaiter

                {

                {

                    promise_type* p_;

                    promise_type* p_;

                    {

                    {

                    }

                    }

                    {

                    {

                    }

                    }

                    {

                    {

                };

                };

            }

            }

                io_result<std::size_t> r) noexcept

                io_result<std::size_t> r) noexcept

            {

            {

            {

            {

            std::suspend_always yield_value(int) noexcept

            std::suspend_always yield_value(int) noexcept

            {

            {

                return {};

                return {};

            }

            }

            template<class A>

            template<class A>

            {

            {

                using decayed = std::decay_t<A>;

                using decayed = std::decay_t<A>;

                if constexpr (IoAwaitable<decayed>)

                if constexpr (IoAwaitable<decayed>)

                {

                {

                    struct wrapper

                    struct wrapper

                    {

                    {

                        decayed inner_;

                        decayed inner_;

                        promise_type* p_;

                        promise_type* p_;

                        {

                        {

                        }

                        }

                        {

                        {

                                &inner_, h,

                                &inner_, h,

                        }

                        }

                        {

                        {

                        }

                        }

                    };

                    };

                    return wrapper{

                    return wrapper{

                }

                }

                else

                else

                {

                {

                    return std::forward<A>(a);

                    return std::forward<A>(a);

                }

                }

            }

            }

            static void*

            static void*

                std::size_t size,

                std::size_t size,

                write_now& self,

                write_now& self,

                auto&)

                auto&)

            {

            {

            }

            }

            static void

            static void

            {

            {

        };

        };

        std::coroutine_handle<promise_type> h_;

        std::coroutine_handle<promise_type> h_;

        {

        {

        op_type(op_type const&) = delete;

        op_type(op_type const&) = delete;

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

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

        {

        {

        op_type& operator=(op_type&&) = delete;

        op_type& operator=(op_type&&) = delete;

        {

        {

        }

        }

            std::coroutine_handle<> cont,

            std::coroutine_handle<> cont,

            io_env const* env)

            io_env const* env)

        {

        {

        }

        }

        {

        {

        }

        }

    private:

    private:

            std::coroutine_handle<promise_type> h)

            std::coroutine_handle<promise_type> h)

        {

        {

    };

    };

public:

public:

    /** Destructor. Frees the cached coroutine frame. */

    /** Destructor. Frees the cached coroutine frame. */

    {

    {

    /** Construct from a stream reference.

    /** Construct from a stream reference.

        @param s The stream to write to. Must outlive this object.

        @param s The stream to write to. Must outlive this object.

    */

    */

    explicit

    explicit

    {

    {

    write_now(write_now const&) = delete;

    write_now(write_now const&) = delete;

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

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

    /** Eagerly write the entire buffer sequence.

    /** Eagerly write the entire buffer sequence.

        Writes data to the stream by calling `write_some` repeatedly

        Writes data to the stream by calling `write_some` repeatedly

        until the entire buffer sequence is written or an error

        until the entire buffer sequence is written or an error

        occurs. The operation attempts to complete synchronously:

        occurs. The operation attempts to complete synchronously:

        if every `write_some` completes without suspending, the

        if every `write_some` completes without suspending, the

        entire operation finishes in `await_ready`.

        entire operation finishes in `await_ready`.

        When the fast path cannot complete, the coroutine suspends

        When the fast path cannot complete, the coroutine suspends

        and continues asynchronously. The internal coroutine frame

        and continues asynchronously. The internal coroutine frame

        is cached and reused across calls.

        is cached and reused across calls.

        @param buffers The buffer sequence to write. Passed by

        @param buffers The buffer sequence to write. Passed by

            value to ensure the sequence lives in the coroutine

            value to ensure the sequence lives in the coroutine

            frame across suspension points.

            frame across suspension points.

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

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

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

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

            error, `n` is the number of bytes written before the

            error, `n` is the number of bytes written before the

            error. Compare error codes to conditions:

            error. Compare error codes to conditions:

            @li `cond::canceled` - Operation was cancelled

            @li `cond::canceled` - Operation was cancelled

            @li `std::errc::broken_pipe` - Peer closed connection

            @li `std::errc::broken_pipe` - Peer closed connection

        @par Example

        @par Example

        @code

        @code

        write_now wn( stream );

        write_now wn( stream );

        auto [ec, n] = co_await wn( make_buffer( body ) );

        auto [ec, n] = co_await wn( make_buffer( body ) );

        if( ec )

        if( ec )

            detail::throw_system_error( ec );

            detail::throw_system_error( ec );

        @endcode

        @endcode

        @see write, write_some, WriteStream

        @see write, write_some, WriteStream

    */

    */

// GCC falsely warns that the coroutine promise's

// GCC falsely warns that the coroutine promise's

// placement operator new(size_t, write_now&, auto&)

// placement operator new(size_t, write_now&, auto&)

// mismatches operator delete(void*, size_t). Per the

// mismatches operator delete(void*, size_t). Per the

// standard, coroutine deallocation lookup is separate.

// standard, coroutine deallocation lookup is separate.

#if defined(__GNUC__) && !defined(__clang__)

#if defined(__GNUC__) && !defined(__clang__)

#pragma GCC diagnostic push

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wmismatched-new-delete"

#pragma GCC diagnostic ignored "-Wmismatched-new-delete"

#endif

#endif

#if BOOST_CAPY_WRITE_NOW_WORKAROUND

#if BOOST_CAPY_WRITE_NOW_WORKAROUND

    template<ConstBufferSequence Buffers>

    template<ConstBufferSequence Buffers>

    op_type

    op_type

    {

    {

        std::size_t const total_size = buffer_size(buffers);

        std::size_t const total_size = buffer_size(buffers);

        std::size_t total_written = 0;

        std::size_t total_written = 0;

        consuming_buffers cb(buffers);

        consuming_buffers cb(buffers);

        while(total_written < total_size)

        while(total_written < total_size)

        {

        {

            auto r =

            auto r =

                co_await stream_.write_some(cb);

                co_await stream_.write_some(cb);

            if(r.ec)

            if(r.ec)

                co_return io_result<std::size_t>{

                co_return io_result<std::size_t>{

                    r.ec, total_written};

                    r.ec, total_written};

            cb.consume(r.t1);

            cb.consume(r.t1);

            total_written += r.t1;

            total_written += r.t1;

        }

        }

        co_return io_result<std::size_t>{

        co_return io_result<std::size_t>{

            {}, total_written};

            {}, total_written};

#else

#else

    template<ConstBufferSequence Buffers>

    template<ConstBufferSequence Buffers>

    op_type

    op_type

    operator()(Buffers buffers)

    operator()(Buffers buffers)

    {

    {

        std::size_t const total_size = buffer_size(buffers);

        std::size_t const total_size = buffer_size(buffers);

        std::size_t total_written = 0;

        std::size_t total_written = 0;

        // GCC ICE in expand_expr_real_1 (expr.cc:11376)

        // GCC ICE in expand_expr_real_1 (expr.cc:11376)

        // when consuming_buffers spans a co_yield, so

        // when consuming_buffers spans a co_yield, so

        // the GCC path uses a separate simple coroutine.

        // the GCC path uses a separate simple coroutine.

        consuming_buffers cb(buffers);

        consuming_buffers cb(buffers);

        while(total_written < total_size)

        while(total_written < total_size)

        {

        {

            auto inner = stream_.write_some(cb);

            auto inner = stream_.write_some(cb);

            if(!inner.await_ready())

            if(!inner.await_ready())

                break;

                break;

            auto r = inner.await_resume();

            auto r = inner.await_resume();

            if(r.ec)

            if(r.ec)

                co_return io_result<std::size_t>{

                co_return io_result<std::size_t>{

                    r.ec, total_written};

                    r.ec, total_written};

            cb.consume(r.t1);

            cb.consume(r.t1);

            total_written += r.t1;

            total_written += r.t1;

        }

        }

        if(total_written >= total_size)

        if(total_written >= total_size)

            co_return io_result<std::size_t>{

            co_return io_result<std::size_t>{

                {}, total_written};

                {}, total_written};

        co_yield 0;

        co_yield 0;

        while(total_written < total_size)

        while(total_written < total_size)

        {

        {

            auto r =

            auto r =

                co_await stream_.write_some(cb);

                co_await stream_.write_some(cb);

            if(r.ec)

            if(r.ec)

                co_return io_result<std::size_t>{

                co_return io_result<std::size_t>{

                    r.ec, total_written};

                    r.ec, total_written};

            cb.consume(r.t1);

            cb.consume(r.t1);

            total_written += r.t1;

            total_written += r.t1;

        }

        }

        co_return io_result<std::size_t>{

        co_return io_result<std::size_t>{

            {}, total_written};

            {}, total_written};

    }

    }

#endif

#endif

#if defined(__GNUC__) && !defined(__clang__)

#if defined(__GNUC__) && !defined(__clang__)

#pragma GCC diagnostic pop

#pragma GCC diagnostic pop

#endif

#endif

};

};

template<WriteStream S>

template<WriteStream S>

write_now(S&) -> write_now<S>;

write_now(S&) -> write_now<S>;

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif