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_READ_HPP

#ifndef BOOST_CAPY_READ_HPP

#define BOOST_CAPY_READ_HPP

#define BOOST_CAPY_READ_HPP

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

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

#include <boost/capy/cond.hpp>

#include <boost/capy/cond.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/task.hpp>

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

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

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

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

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

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

#include <system_error>

#include <system_error>

#include <cstddef>

#include <cstddef>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** Asynchronously read until the buffer sequence is full.

/** Asynchronously read until the buffer sequence is full.

    Reads data from the stream by calling `read_some` repeatedly

    Reads data from the stream by calling `read_some` repeatedly

    until the entire buffer sequence is filled or an error occurs.

    until the entire buffer sequence is filled or an error occurs.

    @li The operation completes when:

    @li The operation completes when:

    @li The buffer sequence is completely filled

    @li The buffer sequence is completely filled

    @li An error occurs (including `cond::eof`)

    @li An error occurs (including `cond::eof`)

    @li The operation is cancelled

    @li The operation is cancelled

    @par Cancellation

    @par Cancellation

    Supports cancellation via `stop_token` propagated through the

    Supports cancellation via `stop_token` propagated through the

    IoAwaitable protocol. When cancelled, returns with `cond::canceled`.

    IoAwaitable protocol. When cancelled, returns with `cond::canceled`.

    @param stream The stream to read from. The caller retains ownership.

    @param stream The stream to read from. The caller retains ownership.

    @param buffers The buffer sequence to fill. The caller retains

    @param buffers The buffer sequence to fill. The caller retains

        ownership and must ensure validity until the operation completes.

        ownership and must ensure validity until the operation completes.

    @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 error,

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

        `n` is the number of bytes read before the error. Compare

        `n` is the number of bytes read before the error. Compare

        error codes to conditions:

        error codes to conditions:

        @li `cond::eof` - Stream reached end before buffer was filled

        @li `cond::eof` - Stream reached end before buffer was filled

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

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

    @par Example

    @par Example

    @code

    @code

    task<> read_message( ReadStream auto& stream )

    task<> read_message( ReadStream auto& stream )

    {

    {

        char header[16];

        char header[16];

        auto [ec, n] = co_await read( stream, mutable_buffer( header ) );

        auto [ec, n] = co_await read( stream, mutable_buffer( header ) );

        if( ec == cond::eof )

        if( ec == cond::eof )

            co_return;  // Connection closed

            co_return;  // Connection closed

        if( ec.failed() )

        if( ec.failed() )

            detail::throw_system_error( ec );

            detail::throw_system_error( ec );

        // header contains exactly 16 bytes

        // header contains exactly 16 bytes

    }

    }

    @endcode

    @endcode

    @see read_some, ReadStream, MutableBufferSequence

    @see read_some, ReadStream, MutableBufferSequence

*/

*/

auto

auto

    ReadStream auto& stream,

    ReadStream auto& stream,

    MutableBufferSequence auto const& buffers) ->

    MutableBufferSequence auto const& buffers) ->

        task<io_result<std::size_t>>

        task<io_result<std::size_t>>

{

{

    consuming_buffers consuming(buffers);

    consuming_buffers consuming(buffers);

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

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

    std::size_t total_read = 0;

    std::size_t total_read = 0;

    while(total_read < total_size)

    while(total_read < total_size)

    {

    {

        auto [ec, n] = co_await stream.read_some(consuming);

        auto [ec, n] = co_await stream.read_some(consuming);

        if(ec)

        if(ec)

            co_return {ec, total_read};

            co_return {ec, total_read};

        consuming.consume(n);

        consuming.consume(n);

        total_read += n;

        total_read += n;

    }

    }

    co_return {{}, total_read};

    co_return {{}, total_read};

/** Asynchronously read all data from a stream into a dynamic buffer.

/** Asynchronously read all data from a stream into a dynamic buffer.

    Reads data by calling `read_some` repeatedly until EOF is reached

    Reads data by calling `read_some` repeatedly until EOF is reached

    or an error occurs. Data is appended using prepare/commit semantics.

    or an error occurs. Data is appended using prepare/commit semantics.

    The buffer grows with 1.5x factor when filled.

    The buffer grows with 1.5x factor when filled.

    @li The operation completes when:

    @li The operation completes when:

    @li End-of-stream is reached (`cond::eof`)

    @li End-of-stream is reached (`cond::eof`)

    @li An error occurs

    @li An error occurs

    @li The operation is cancelled

    @li The operation is cancelled

    @par Cancellation

    @par Cancellation

    Supports cancellation via `stop_token` propagated through the

    Supports cancellation via `stop_token` propagated through the

    IoAwaitable protocol. When cancelled, returns with `cond::canceled`.

    IoAwaitable protocol. When cancelled, returns with `cond::canceled`.

    @param stream The stream to read from. The caller retains ownership.

    @param stream The stream to read from. The caller retains ownership.

    @param buffers The dynamic buffer to append data to. Must remain

    @param buffers The dynamic buffer to append data to. Must remain

        valid until the operation completes.

        valid until the operation completes.

    @param initial_amount Initial bytes to prepare (default 2048).

    @param initial_amount Initial bytes to prepare (default 2048).

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

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

        On success (EOF), `ec` is clear and `n` is total bytes read.

        On success (EOF), `ec` is clear and `n` is total bytes read.

        On error, `n` is bytes read before the error. Compare error

        On error, `n` is bytes read before the error. Compare error

        codes to conditions:

        codes to conditions:

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

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

    @par Example

    @par Example

    @code

    @code

    task<std::string> read_body( ReadStream auto& stream )

    task<std::string> read_body( ReadStream auto& stream )

    {

    {

        std::string body;

        std::string body;

        auto [ec, n] = co_await read( stream, string_dynamic_buffer( &body ) );

        auto [ec, n] = co_await read( stream, string_dynamic_buffer( &body ) );

        if( ec.failed() )

        if( ec.failed() )

            detail::throw_system_error( ec );

            detail::throw_system_error( ec );

        return body;

        return body;

    }

    }

    @endcode

    @endcode

    @see read_some, ReadStream, DynamicBufferParam

    @see read_some, ReadStream, DynamicBufferParam

*/

*/

auto

auto

    ReadStream auto& stream,

    ReadStream auto& stream,

    DynamicBufferParam auto&& buffers,

    DynamicBufferParam auto&& buffers,

    std::size_t initial_amount = 2048) ->

    std::size_t initial_amount = 2048) ->

        task<io_result<std::size_t>>

        task<io_result<std::size_t>>

{

{

    std::size_t amount = initial_amount;

    std::size_t amount = initial_amount;

    std::size_t total_read = 0;

    std::size_t total_read = 0;

    for(;;)

    for(;;)

    {

    {

        auto mb = buffers.prepare(amount);

        auto mb = buffers.prepare(amount);

        auto const mb_size = buffer_size(mb);

        auto const mb_size = buffer_size(mb);

        auto [ec, n] = co_await stream.read_some(mb);

        auto [ec, n] = co_await stream.read_some(mb);

        buffers.commit(n);

        buffers.commit(n);

        total_read += n;

        total_read += n;

        if(ec == cond::eof)

        if(ec == cond::eof)

            co_return {{}, total_read};

            co_return {{}, total_read};

        if(ec)

        if(ec)

            co_return {ec, total_read};

            co_return {ec, total_read};

        if(n == mb_size)

        if(n == mb_size)

            amount = amount / 2 + amount;

            amount = amount / 2 + amount;

    }

    }

/** Asynchronously read all data from a source into a dynamic buffer.

/** Asynchronously read all data from a source into a dynamic buffer.

    Reads data by calling `source.read` repeatedly until EOF is reached

    Reads data by calling `source.read` repeatedly until EOF is reached

    or an error occurs. Data is appended using prepare/commit semantics.

    or an error occurs. Data is appended using prepare/commit semantics.

    The buffer grows with 1.5x factor when filled.

    The buffer grows with 1.5x factor when filled.

    @li The operation completes when:

    @li The operation completes when:

    @li End-of-stream is reached (`cond::eof`)

    @li End-of-stream is reached (`cond::eof`)

    @li An error occurs

    @li An error occurs

    @li The operation is cancelled

    @li The operation is cancelled

    @par Cancellation

    @par Cancellation

    Supports cancellation via `stop_token` propagated through the

    Supports cancellation via `stop_token` propagated through the

    IoAwaitable protocol. When cancelled, returns with `cond::canceled`.

    IoAwaitable protocol. When cancelled, returns with `cond::canceled`.

    @param source The source to read from. The caller retains ownership.

    @param source The source to read from. The caller retains ownership.

    @param buffers The dynamic buffer to append data to. Must remain

    @param buffers The dynamic buffer to append data to. Must remain

        valid until the operation completes.

        valid until the operation completes.

    @param initial_amount Initial bytes to prepare (default 2048).

    @param initial_amount Initial bytes to prepare (default 2048).

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

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

        On success (EOF), `ec` is clear and `n` is total bytes read.

        On success (EOF), `ec` is clear and `n` is total bytes read.

        On error, `n` is bytes read before the error. Compare error

        On error, `n` is bytes read before the error. Compare error

        codes to conditions:

        codes to conditions:

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

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

    @par Example

    @par Example

    @code

    @code

    task<std::string> read_body( ReadSource auto& source )

    task<std::string> read_body( ReadSource auto& source )

    {

    {

        std::string body;

        std::string body;

        auto [ec, n] = co_await read( source, string_dynamic_buffer( &body ) );

        auto [ec, n] = co_await read( source, string_dynamic_buffer( &body ) );

        if( ec.failed() )

        if( ec.failed() )

            detail::throw_system_error( ec );

            detail::throw_system_error( ec );

        return body;

        return body;

    }

    }

    @endcode

    @endcode

    @see ReadSource, DynamicBufferParam

    @see ReadSource, DynamicBufferParam

*/

*/

auto

auto

    ReadSource auto& source,

    ReadSource auto& source,

    DynamicBufferParam auto&& buffers,

    DynamicBufferParam auto&& buffers,

    std::size_t initial_amount = 2048) ->

    std::size_t initial_amount = 2048) ->

        task<io_result<std::size_t>>

        task<io_result<std::size_t>>

{

{

    std::size_t amount = initial_amount;

    std::size_t amount = initial_amount;

    std::size_t total_read = 0;

    std::size_t total_read = 0;

    for(;;)

    for(;;)

    {

    {

        auto mb = buffers.prepare(amount);

        auto mb = buffers.prepare(amount);

        auto const mb_size = buffer_size(mb);

        auto const mb_size = buffer_size(mb);

        auto [ec, n] = co_await source.read(mb);

        auto [ec, n] = co_await source.read(mb);

        buffers.commit(n);

        buffers.commit(n);

        total_read += n;

        total_read += n;

        if(ec == cond::eof)

        if(ec == cond::eof)

            co_return {{}, total_read};

            co_return {{}, total_read};

        if(ec)

        if(ec)

            co_return {ec, total_read};

            co_return {ec, total_read};

        if(n == mb_size)

        if(n == mb_size)

            amount = amount / 2 + amount; // 1.5x growth

            amount = amount / 2 + amount; // 1.5x growth

    }

    }

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif