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_READ_UNTIL_HPP

#ifndef BOOST_CAPY_READ_UNTIL_HPP

#define BOOST_CAPY_READ_UNTIL_HPP

#define BOOST_CAPY_READ_UNTIL_HPP

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

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

#include <boost/capy/buffers.hpp>

#include <boost/capy/buffers.hpp>

#include <boost/capy/cond.hpp>

#include <boost/capy/cond.hpp>

#include <coroutine>

#include <coroutine>

#include <boost/capy/error.hpp>

#include <boost/capy/error.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_result.hpp>

#include <boost/capy/io_task.hpp>

#include <boost/capy/io_task.hpp>

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

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

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

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

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

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

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

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

#include <algorithm>

#include <algorithm>

#include <cstddef>

#include <cstddef>

#include <optional>

#include <optional>

#include <stop_token>

#include <stop_token>

#include <string_view>

#include <string_view>

#include <type_traits>

#include <type_traits>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

namespace detail {

namespace detail {

// Linearize a buffer sequence into a string

// Linearize a buffer sequence into a string

inline

inline

std::string

std::string

{

{

            it->size());

            it->size());

// Search buffer using a MatchCondition, with single-buffer optimization

// Search buffer using a MatchCondition, with single-buffer optimization

template<MatchCondition M>

template<MatchCondition M>

std::size_t

std::size_t

    ConstBufferSequence auto const& data,

    ConstBufferSequence auto const& data,

    M const& match,

    M const& match,

    std::size_t* hint = nullptr)

    std::size_t* hint = nullptr)

{

{

    // Fast path: single buffer - no linearization needed

    // Fast path: single buffer - no linearization needed

    {

    {

    }

    }

    // Multiple buffers - linearize

    // Multiple buffers - linearize

}

}

// Implementation coroutine for read_until with MatchCondition

// Implementation coroutine for read_until with MatchCondition

template<class Stream, class B, MatchCondition M>

template<class Stream, class B, MatchCondition M>

io_task<std::size_t>

io_task<std::size_t>

    Stream& stream,

    Stream& stream,

    B& buffers,

    B& buffers,

    M match,

    M match,

    std::size_t initial_amount)

    std::size_t initial_amount)

{

{

    std::size_t amount = initial_amount;

    std::size_t amount = initial_amount;

    for(;;)

    for(;;)

    {

    {

        // Check max_size before preparing

        // Check max_size before preparing

        if(buffers.size() >= buffers.max_size())

        if(buffers.size() >= buffers.max_size())

            co_return {error::not_found, 0};

            co_return {error::not_found, 0};

        // Prepare space, respecting max_size

        // Prepare space, respecting max_size

        std::size_t const available = buffers.max_size() - buffers.size();

        std::size_t const available = buffers.max_size() - buffers.size();

        std::size_t const to_prepare = (std::min)(amount, available);

        std::size_t const to_prepare = (std::min)(amount, available);

        if(to_prepare == 0)

        if(to_prepare == 0)

            co_return {error::not_found, 0};

            co_return {error::not_found, 0};

        auto mb = buffers.prepare(to_prepare);

        auto mb = buffers.prepare(to_prepare);

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

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

        buffers.commit(n);

        buffers.commit(n);

        if(!ec)

        if(!ec)

        {

        {

            auto pos = search_buffer_for_match(buffers.data(), match);

            auto pos = search_buffer_for_match(buffers.data(), match);

            if(pos != std::string_view::npos)

            if(pos != std::string_view::npos)

                co_return {{}, pos};

                co_return {{}, pos};

        }

        }

        if(ec == cond::eof)

        if(ec == cond::eof)

            co_return {error::eof, buffers.size()};

            co_return {error::eof, buffers.size()};

        if(ec)

        if(ec)

            co_return {ec, buffers.size()};

            co_return {ec, buffers.size()};

        // Grow buffer size for next iteration

        // Grow buffer size for next iteration

        if(n == buffer_size(mb))

        if(n == buffer_size(mb))

            amount = amount / 2 + amount;

            amount = amount / 2 + amount;

    }

    }

template<class Stream, class B, MatchCondition M, bool OwnsBuffer>

template<class Stream, class B, MatchCondition M, bool OwnsBuffer>

struct read_until_awaitable

struct read_until_awaitable

{

{

    Stream* stream_;

    Stream* stream_;

    M match_;

    M match_;

    std::size_t initial_amount_;

    std::size_t initial_amount_;

    std::optional<io_result<std::size_t>> immediate_;

    std::optional<io_result<std::size_t>> immediate_;

    std::optional<io_task<std::size_t>> inner_;

    std::optional<io_task<std::size_t>> inner_;

    using storage_type = std::conditional_t<OwnsBuffer, B, B*>;

    using storage_type = std::conditional_t<OwnsBuffer, B, B*>;

    storage_type buffers_storage_;

    storage_type buffers_storage_;

    {

    {

        if constexpr(OwnsBuffer)

        if constexpr(OwnsBuffer)

        else

        else

    }

    }

    // Constructor for lvalue (pointer storage)

    // Constructor for lvalue (pointer storage)

        Stream& stream,

        Stream& stream,

        B* buffers,

        B* buffers,

        M match,

        M match,

        std::size_t initial_amount)

        std::size_t initial_amount)

        requires (!OwnsBuffer)

        requires (!OwnsBuffer)

    {

    {

    // Constructor for rvalue adapter (owned storage)

    // Constructor for rvalue adapter (owned storage)

        Stream& stream,

        Stream& stream,

        B&& buffers,

        B&& buffers,

        M match,

        M match,

        std::size_t initial_amount)

        std::size_t initial_amount)

        requires OwnsBuffer

        requires OwnsBuffer

    {

    {

    bool

    bool

    {

    {

    }

    }

    std::coroutine_handle<>

    std::coroutine_handle<>

    {

    {

    }

    }

    io_result<std::size_t>

    io_result<std::size_t>

    {

    {

    }

    }

};

};

} // namespace detail

} // namespace detail

/** Match condition that searches for a delimiter string.

/** Match condition that searches for a delimiter string.

    Satisfies @ref MatchCondition. Returns the position after the

    Satisfies @ref MatchCondition. Returns the position after the

    delimiter when found, or `npos` otherwise. Provides an overlap

    delimiter when found, or `npos` otherwise. Provides an overlap

    hint of `delim.size() - 1` to handle delimiters spanning reads.

    hint of `delim.size() - 1` to handle delimiters spanning reads.

    @see MatchCondition, read_until

    @see MatchCondition, read_until

*/

*/

struct match_delim

struct match_delim

    /** The delimiter string to search for.

        @note The referenced characters must remain valid

            for the lifetime of this object and any pending

            read operation.

    */

{

{

    std::string_view delim;

    std::string_view delim;

    /** Search for the delimiter in `data`.

        @param data The data to search.

        @param hint If non-null, receives the overlap hint

            on miss.

        @return `0` if `delim` is empty; otherwise the position

            just past the delimiter, or `npos` if not found.

    */

    std::size_t

    std::size_t

        std::string_view data,

        std::string_view data,

        std::size_t* hint) const noexcept

        std::size_t* hint) const noexcept

    {

    {

    }

    }

};

};

/** Asynchronously read until a match condition is satisfied.

/** Asynchronously read until a match condition is satisfied.

    Reads data from the stream into the dynamic buffer until the match

    Reads data from the stream into the dynamic buffer until the match

    condition returns a valid position. Implemented using `read_some`.

    condition returns a valid position. Implemented using `read_some`.

    If the match condition is already satisfied by existing buffer

    If the match condition is already satisfied by existing buffer

    data, returns immediately without I/O.

    data, returns immediately without I/O.

    @li The operation completes when:

    @li The operation completes when:

    @li The match condition returns a valid position

    @li The match condition returns a valid position

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

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

    @li The buffer's `max_size()` is reached (`cond::not_found`)

    @li The buffer's `max_size()` is reached (`cond::not_found`)

    @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 match The match condition callable. Copied into the awaitable.

    @param match The match condition callable. Copied into the awaitable.

    @param initial_amount Initial bytes to read per iteration (default

    @param initial_amount Initial bytes to read per iteration (default

        2048). Grows by 1.5x when filled.

        2048). Grows by 1.5x when filled.

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

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

        On success, `n` is the position returned by the match condition

        On success, `n` is the position returned by the match condition

        (bytes up to and including the matched delimiter). Compare error

        (bytes up to and including the matched delimiter). Compare error

        codes to conditions:

        codes to conditions:

        @li `cond::eof` - EOF before match; `n` is buffer size

        @li `cond::eof` - EOF before match; `n` is buffer size

        @li `cond::not_found` - `max_size()` reached before match

        @li `cond::not_found` - `max_size()` reached before match

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

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

    @par Example

    @par Example

    @code

    @code

    task<> read_http_header( ReadStream auto& stream )

    task<> read_http_header( ReadStream auto& stream )

    {

    {

        std::string header;

        std::string header;

        auto [ec, n] = co_await read_until(

        auto [ec, n] = co_await read_until(

            stream,

            stream,

            string_dynamic_buffer( &header ),

            string_dynamic_buffer( &header ),

            []( std::string_view data, std::size_t* hint ) {

            []( std::string_view data, std::size_t* hint ) {

                auto pos = data.find( "\r\n\r\n" );

                auto pos = data.find( "\r\n\r\n" );

                if( pos != std::string_view::npos )

                if( pos != std::string_view::npos )

                    return pos + 4;

                    return pos + 4;

                if( hint )

                if( hint )

                    *hint = 3;  // partial "\r\n\r" possible

                    *hint = 3;  // partial "\r\n\r" possible

                return std::string_view::npos;

                return std::string_view::npos;

            } );

            } );

        if( ec )

        if( ec )

            detail::throw_system_error( ec );

            detail::throw_system_error( ec );

        // header contains data through "\r\n\r\n"

        // header contains data through "\r\n\r\n"

    }

    }

    @endcode

    @endcode

    @see read_some, MatchCondition, DynamicBufferParam

    @see read_some, MatchCondition, DynamicBufferParam

*/

*/

template<ReadStream Stream, class B, MatchCondition M>

template<ReadStream Stream, class B, MatchCondition M>

    requires DynamicBufferParam<B&&>

    requires DynamicBufferParam<B&&>

auto

auto

    Stream& stream,

    Stream& stream,

    B&& buffers,

    B&& buffers,

    M match,

    M match,

    std::size_t initial_amount = 2048)

    std::size_t initial_amount = 2048)

{

{

    using BareB = std::remove_reference_t<B>;

    using BareB = std::remove_reference_t<B>;

    if constexpr(is_lvalue)

    if constexpr(is_lvalue)

        return detail::read_until_awaitable<Stream, BareB, M, false>(

        return detail::read_until_awaitable<Stream, BareB, M, false>(

    else

    else

        return detail::read_until_awaitable<Stream, BareB, M, true>(

        return detail::read_until_awaitable<Stream, BareB, M, true>(

}

}

/** Asynchronously read until a delimiter string is found.

/** Asynchronously read until a delimiter string is found.

    Reads data from the stream until the delimiter is found. This is

    Reads data from the stream until the delimiter is found. This is

    a convenience overload equivalent to calling `read_until` with

    a convenience overload equivalent to calling `read_until` with

    `match_delim{delim}`. If the delimiter already exists in the

    `match_delim{delim}`. If the delimiter already exists in the

    buffer, returns immediately without I/O.

    buffer, returns immediately without I/O.

    @li The operation completes when:

    @li The operation completes when:

    @li The delimiter string is found

    @li The delimiter string is found

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

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

    @li The buffer's `max_size()` is reached (`cond::not_found`)

    @li The buffer's `max_size()` is reached (`cond::not_found`)

    @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 delim The delimiter string to search for.

    @param delim The delimiter string to search for.

    @param initial_amount Initial bytes to read per iteration (default

    @param initial_amount Initial bytes to read per iteration (default

        2048). Grows by 1.5x when filled.

        2048). Grows by 1.5x when filled.

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

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

        On success, `n` is bytes up to and including the delimiter.

        On success, `n` is bytes up to and including the delimiter.

        Compare error codes to conditions:

        Compare error codes to conditions:

        @li `cond::eof` - EOF before delimiter; `n` is buffer size

        @li `cond::eof` - EOF before delimiter; `n` is buffer size

        @li `cond::not_found` - `max_size()` reached before delimiter

        @li `cond::not_found` - `max_size()` reached before delimiter

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

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

    @par Example

    @par Example

    @code

    @code

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

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

    {

    {

        std::string line;

        std::string line;

        auto [ec, n] = co_await read_until(

        auto [ec, n] = co_await read_until(

            stream, string_dynamic_buffer( &line ), "\r\n" );

            stream, string_dynamic_buffer( &line ), "\r\n" );

        if( ec == cond::eof )

        if( ec == cond::eof )

            co_return line;  // partial line at EOF

            co_return line;  // partial line at EOF

        if( ec )

        if( ec )

            detail::throw_system_error( ec );

            detail::throw_system_error( ec );

        line.resize( n - 2 );  // remove "\r\n"

        line.resize( n - 2 );  // remove "\r\n"

        co_return line;

        co_return line;

    }

    }

    @endcode

    @endcode

    @see read_until, match_delim, DynamicBufferParam

    @see read_until, match_delim, DynamicBufferParam

*/

*/

template<ReadStream Stream, class B>

template<ReadStream Stream, class B>

    requires DynamicBufferParam<B&&>

    requires DynamicBufferParam<B&&>

auto

auto

    Stream& stream,

    Stream& stream,

    B&& buffers,

    B&& buffers,

    std::string_view delim,

    std::string_view delim,

    std::size_t initial_amount = 2048)

    std::size_t initial_amount = 2048)

{

{

    return read_until(

    return read_until(

        stream,

        stream,

        std::forward<B>(buffers),

        std::forward<B>(buffers),

        match_delim{delim},

        match_delim{delim},

}

}

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif