Diff coverage report for

//

//

// Copyright (c) 2026 Steve Gerbino

// Copyright (c) 2026 Steve Gerbino

//

//

// 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_WHEN_ALL_HPP

#ifndef BOOST_CAPY_WHEN_ALL_HPP

#define BOOST_CAPY_WHEN_ALL_HPP

#define BOOST_CAPY_WHEN_ALL_HPP

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

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

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

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

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

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

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

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

#include <coroutine>

#include <coroutine>

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

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

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

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

#include <boost/capy/task.hpp>

#include <boost/capy/task.hpp>

#include <array>

#include <array>

#include <atomic>

#include <atomic>

#include <exception>

#include <exception>

#include <optional>

#include <optional>

#include <stop_token>

#include <stop_token>

#include <tuple>

#include <tuple>

#include <type_traits>

#include <type_traits>

#include <utility>

#include <utility>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

namespace detail {

namespace detail {

/** Holds the result of a single task within when_all.

/** Holds the result of a single task within when_all.

*/

*/

template<typename T>

template<typename T>

struct result_holder

struct result_holder

{

{

    std::optional<T> value_;

    std::optional<T> value_;

    {

    {

    {

    {

    }

    }

};

};

/** Specialization for void tasks - returns monostate to preserve index mapping.

/** Specialization for void tasks - returns monostate to preserve index mapping.

*/

*/

template<>

template<>

struct result_holder<void>

struct result_holder<void>

{

{

};

};

/** Shared state for when_all operation.

/** Shared state for when_all operation.

    @tparam Ts The result types of the tasks.

    @tparam Ts The result types of the tasks.

*/

*/

template<typename... Ts>

template<typename... Ts>

struct when_all_state

struct when_all_state

{

{

    static constexpr std::size_t task_count = sizeof...(Ts);

    static constexpr std::size_t task_count = sizeof...(Ts);

    // Completion tracking - when_all waits for all children

    // Completion tracking - when_all waits for all children

    std::atomic<std::size_t> remaining_count_;

    std::atomic<std::size_t> remaining_count_;

    // Result storage in input order

    // Result storage in input order

    std::tuple<result_holder<Ts>...> results_;

    std::tuple<result_holder<Ts>...> results_;

    // Runner handles - destroyed in await_resume while allocator is valid

    // Runner handles - destroyed in await_resume while allocator is valid

    std::array<std::coroutine_handle<>, task_count> runner_handles_{};

    std::array<std::coroutine_handle<>, task_count> runner_handles_{};

    // Exception storage - first error wins, others discarded

    // Exception storage - first error wins, others discarded

    std::atomic<bool> has_exception_{false};

    std::atomic<bool> has_exception_{false};

    std::exception_ptr first_exception_;

    std::exception_ptr first_exception_;

    // Stop propagation - on error, request stop for siblings

    // Stop propagation - on error, request stop for siblings

    std::stop_source stop_source_;

    std::stop_source stop_source_;

    // Connects parent's stop_token to our stop_source

    // Connects parent's stop_token to our stop_source

    struct stop_callback_fn

    struct stop_callback_fn

    {

    {

        std::stop_source* source_;

        std::stop_source* source_;

    };

    };

    using stop_callback_t = std::stop_callback<stop_callback_fn>;

    using stop_callback_t = std::stop_callback<stop_callback_fn>;

    std::optional<stop_callback_t> parent_stop_callback_;

    std::optional<stop_callback_t> parent_stop_callback_;

    // Parent resumption

    // Parent resumption

    std::coroutine_handle<> continuation_;

    std::coroutine_handle<> continuation_;

    io_env const* caller_env_ = nullptr;

    io_env const* caller_env_ = nullptr;

    {

    {

    // Runners self-destruct in final_suspend. No destruction needed here.

    // Runners self-destruct in final_suspend. No destruction needed here.

    /** Capture an exception (first one wins).

    /** Capture an exception (first one wins).

    */

    */

    {

    {

            expected, true, std::memory_order_relaxed))

            expected, true, std::memory_order_relaxed))

};

};

/** Wrapper coroutine that intercepts task completion.

/** Wrapper coroutine that intercepts task completion.

    This runner awaits its assigned task and stores the result in

    This runner awaits its assigned task and stores the result in

    the shared state, or captures the exception and requests stop.

    the shared state, or captures the exception and requests stop.

*/

*/

template<typename T, typename... Ts>

template<typename T, typename... Ts>

struct when_all_runner

struct when_all_runner

{

{

    struct promise_type // : frame_allocating_base  // DISABLED FOR TESTING

    struct promise_type // : frame_allocating_base  // DISABLED FOR TESTING

    {

    {

        when_all_state<Ts...>* state_ = nullptr;

        when_all_state<Ts...>* state_ = nullptr;

        io_env env_;

        io_env env_;

        {

        {

        }

        }

        {

        {

        }

        }

        {

        {

            struct awaiter

            struct awaiter

            {

            {

                promise_type* p_;

                promise_type* p_;

                {

                {

                }

                }

                {

                {

                    // Extract everything needed before self-destruction.

                    // Extract everything needed before self-destruction.

                    // If last runner, dispatch parent for symmetric transfer.

                    // If last runner, dispatch parent for symmetric transfer.

                }

                }

                {

                {

            };

            };

        }

        }

        {

        {

        {

        {

            // Request stop for sibling tasks

            // Request stop for sibling tasks

        template<class Awaitable>

        template<class Awaitable>

        struct transform_awaiter

        struct transform_awaiter

        {

        {

            std::decay_t<Awaitable> a_;

            std::decay_t<Awaitable> a_;

            promise_type* p_;

            promise_type* p_;

            {

            {

            }

            }

            {

            {

            }

            }

            template<class Promise>

            template<class Promise>

            {

            {

                using R = decltype(a_.await_suspend(h, &p_->env_));

                using R = decltype(a_.await_suspend(h, &p_->env_));

                if constexpr (std::is_same_v<R, std::coroutine_handle<>>)

                if constexpr (std::is_same_v<R, std::coroutine_handle<>>)

                else

                else

                    return a_.await_suspend(h, &p_->env_);

                    return a_.await_suspend(h, &p_->env_);

            }

            }

        };

        };

        template<class Awaitable>

        template<class Awaitable>

        {

        {

            using A = std::decay_t<Awaitable>;

            using A = std::decay_t<Awaitable>;

            if constexpr (IoAwaitable<A>)

            if constexpr (IoAwaitable<A>)

            {

            {

                return transform_awaiter<Awaitable>{

                return transform_awaiter<Awaitable>{

            }

            }

            else

            else

            {

            {

                static_assert(sizeof(A) == 0, "requires IoAwaitable");

                static_assert(sizeof(A) == 0, "requires IoAwaitable");

            }

            }

    };

    };

    std::coroutine_handle<promise_type> h_;

    std::coroutine_handle<promise_type> h_;

    {

    {

    // Enable move for all clang versions - some versions need it

    // Enable move for all clang versions - some versions need it

    when_all_runner(when_all_runner&& other) noexcept : h_(std::exchange(other.h_, nullptr)) {}

    when_all_runner(when_all_runner&& other) noexcept : h_(std::exchange(other.h_, nullptr)) {}

    // Non-copyable

    // Non-copyable

    when_all_runner(when_all_runner const&) = delete;

    when_all_runner(when_all_runner const&) = delete;

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

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

    when_all_runner& operator=(when_all_runner&&) = delete;

    when_all_runner& operator=(when_all_runner&&) = delete;

    {

    {

    }

    }

};

};

/** Create a runner coroutine for a single awaitable.

/** Create a runner coroutine for a single awaitable.

    Awaitable is passed directly to ensure proper coroutine frame storage.

    Awaitable is passed directly to ensure proper coroutine frame storage.

*/

*/

template<std::size_t Index, IoAwaitable Awaitable, typename... Ts>

template<std::size_t Index, IoAwaitable Awaitable, typename... Ts>

when_all_runner<awaitable_result_t<Awaitable>, Ts...>

when_all_runner<awaitable_result_t<Awaitable>, Ts...>

{

{

    using T = awaitable_result_t<Awaitable>;

    using T = awaitable_result_t<Awaitable>;

    if constexpr (std::is_void_v<T>)

    if constexpr (std::is_void_v<T>)

    {

    {

        co_await std::move(inner);

        co_await std::move(inner);

    }

    }

    else

    else

    {

    {

        std::get<Index>(state->results_).set(co_await std::move(inner));

        std::get<Index>(state->results_).set(co_await std::move(inner));

    }

    }

/** Internal awaitable that launches all runner coroutines and waits.

/** Internal awaitable that launches all runner coroutines and waits.

    This awaitable is used inside the when_all coroutine to handle

    This awaitable is used inside the when_all coroutine to handle

    the concurrent execution of child awaitables.

    the concurrent execution of child awaitables.

*/

*/

template<IoAwaitable... Awaitables>

template<IoAwaitable... Awaitables>

class when_all_launcher

class when_all_launcher

{

{

    using state_type = when_all_state<awaitable_result_t<Awaitables>...>;

    using state_type = when_all_state<awaitable_result_t<Awaitables>...>;

    std::tuple<Awaitables...>* awaitables_;

    std::tuple<Awaitables...>* awaitables_;

    state_type* state_;

    state_type* state_;

public:

public:

        std::tuple<Awaitables...>* awaitables,

        std::tuple<Awaitables...>* awaitables,

        state_type* state)

        state_type* state)

    {

    {

    {

    {

    }

    }

    {

    {

        // Forward parent's stop requests to children

        // Forward parent's stop requests to children

        {

        {

        }

        }

        // CRITICAL: If the last task finishes synchronously then the parent

        // CRITICAL: If the last task finishes synchronously then the parent

        // coroutine resumes, destroying its frame, and destroying this object

        // coroutine resumes, destroying its frame, and destroying this object

        // prior to the completion of await_suspend. Therefore, await_suspend

        // prior to the completion of await_suspend. Therefore, await_suspend

        // must ensure `this` cannot be referenced after calling `launch_one`

        // must ensure `this` cannot be referenced after calling `launch_one`

        // for the last time.

        // for the last time.

        // Let signal_completion() handle resumption

        // Let signal_completion() handle resumption

    {

    {

        // Results are extracted by the when_all coroutine from state

        // Results are extracted by the when_all coroutine from state

private:

private:

    template<std::size_t I>

    template<std::size_t I>

    {

    {

};

};

/** Helper to extract a single result from state.

/** Helper to extract a single result from state.

    This is a separate function to work around a GCC-11 ICE that occurs

    This is a separate function to work around a GCC-11 ICE that occurs

    when using nested immediately-invoked lambdas with pack expansion.

    when using nested immediately-invoked lambdas with pack expansion.

*/

*/

template<std::size_t I, typename... Ts>

template<std::size_t I, typename... Ts>

{

{

}

}

/** Extract all results from state as a tuple.

/** Extract all results from state as a tuple.

*/

*/

template<typename... Ts>

template<typename... Ts>

{

{

}

}

} // namespace detail

} // namespace detail

/** Compute the when_all result tuple type.

/** Compute the when_all result tuple type.

    Void-returning tasks contribute std::monostate to preserve the

    Void-returning tasks contribute std::monostate to preserve the

    task-index-to-result-index mapping, matching when_any's approach.

    task-index-to-result-index mapping, matching when_any's approach.

    Example: when_all_result_t<int, void, string> = std::tuple<int, std::monostate, string>

    Example: when_all_result_t<int, void, string> = std::tuple<int, std::monostate, string>

    Example: when_all_result_t<void, void> = std::tuple<std::monostate, std::monostate>

    Example: when_all_result_t<void, void> = std::tuple<std::monostate, std::monostate>

*/

*/

template<typename... Ts>

template<typename... Ts>

using when_all_result_t = std::tuple<void_to_monostate_t<Ts>...>;

using when_all_result_t = std::tuple<void_to_monostate_t<Ts>...>;

/** Execute multiple awaitables concurrently and collect their results.

/** Execute multiple awaitables concurrently and collect their results.

    Launches all awaitables simultaneously and waits for all to complete

    Launches all awaitables simultaneously and waits for all to complete

    before returning. Results are collected in input order. If any

    before returning. Results are collected in input order. If any

    awaitable throws, cancellation is requested for siblings and the first

    awaitable throws, cancellation is requested for siblings and the first

    exception is rethrown after all awaitables complete.

    exception is rethrown after all awaitables complete.

    @li All child awaitables run concurrently on the caller's executor

    @li All child awaitables run concurrently on the caller's executor

    @li Results are returned as a tuple in input order

    @li Results are returned as a tuple in input order

    @li Void-returning awaitables contribute std::monostate to the

    @li Void-returning awaitables contribute std::monostate to the

        result tuple, preserving the task-index-to-result-index mapping

        result tuple, preserving the task-index-to-result-index mapping

    @li First exception wins; subsequent exceptions are discarded

    @li First exception wins; subsequent exceptions are discarded

    @li Stop is requested for siblings on first error

    @li Stop is requested for siblings on first error

    @li Completes only after all children have finished

    @li Completes only after all children have finished

    @par Thread Safety

    @par Thread Safety

    The returned task must be awaited from a single execution context.

    The returned task must be awaited from a single execution context.

    Child awaitables execute concurrently but complete through the caller's

    Child awaitables execute concurrently but complete through the caller's

    executor.

    executor.

    @param awaitables The awaitables to execute concurrently. Each must

    @param awaitables The awaitables to execute concurrently. Each must

        satisfy @ref IoAwaitable and is consumed (moved-from) when

        satisfy @ref IoAwaitable and is consumed (moved-from) when

        `when_all` is awaited.

        `when_all` is awaited.

    @return A task yielding a tuple of results in input order. Void tasks

    @return A task yielding a tuple of results in input order. Void tasks

        contribute std::monostate to preserve index correspondence.

        contribute std::monostate to preserve index correspondence.

    @par Example

    @par Example

    @code

    @code

    task<> example()

    task<> example()

    {

    {

        // Concurrent fetch, results collected in order

        // Concurrent fetch, results collected in order

        auto [user, posts] = co_await when_all(

        auto [user, posts] = co_await when_all(

            fetch_user( id ),      // task<User>

            fetch_user( id ),      // task<User>

            fetch_posts( id )      // task<std::vector<Post>>

            fetch_posts( id )      // task<std::vector<Post>>

        );

        );

        // Void awaitables contribute monostate

        // Void awaitables contribute monostate

        auto [a, _, b] = co_await when_all(

        auto [a, _, b] = co_await when_all(

            fetch_int(),           // task<int>

            fetch_int(),           // task<int>

            log_event( "start" ),  // task<void>  → monostate

            log_event( "start" ),  // task<void>  → monostate

            fetch_str()            // task<string>

            fetch_str()            // task<string>

        );

        );

        // a is int, _ is monostate, b is string

        // a is int, _ is monostate, b is string

    }

    }

    @endcode

    @endcode

    @see IoAwaitable, task

    @see IoAwaitable, task

*/

*/

template<IoAwaitable... As>

template<IoAwaitable... As>

    -> task<when_all_result_t<awaitable_result_t<As>...>>

    -> task<when_all_result_t<awaitable_result_t<As>...>>

{

{

    // State is stored in the coroutine frame, using the frame allocator

    // State is stored in the coroutine frame, using the frame allocator

    detail::when_all_state<awaitable_result_t<As>...> state;

    detail::when_all_state<awaitable_result_t<As>...> state;

    // Store awaitables in the frame

    // Store awaitables in the frame

    std::tuple<As...> awaitable_tuple(std::move(awaitables)...);

    std::tuple<As...> awaitable_tuple(std::move(awaitables)...);

    // Launch all awaitables and wait for completion

    // Launch all awaitables and wait for completion

    co_await detail::when_all_launcher<As...>(&awaitable_tuple, &state);

    co_await detail::when_all_launcher<As...>(&awaitable_tuple, &state);

    // Propagate first exception if any.

    // Propagate first exception if any.

    // Safe without explicit acquire: capture_exception() is sequenced-before

    // Safe without explicit acquire: capture_exception() is sequenced-before

    // signal_completion()'s acq_rel fetch_sub, which synchronizes-with the

    // signal_completion()'s acq_rel fetch_sub, which synchronizes-with the

    // last task's decrement that resumes this coroutine.

    // last task's decrement that resumes this coroutine.

    if(state.first_exception_)

    if(state.first_exception_)

        std::rethrow_exception(state.first_exception_);

        std::rethrow_exception(state.first_exception_);

    co_return detail::extract_results(state);

    co_return detail::extract_results(state);

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif