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/concept/executor.hpp>

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

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

#include <boost/capy/concept/io_awaitable.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/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 {

/** Type trait to filter void types from a tuple.

/** Type trait to filter void types from a tuple.

    Void-returning tasks do not contribute a value to the result tuple.

    Void-returning tasks do not contribute a value to the result tuple.

    This trait computes the filtered result type.

    This trait computes the filtered result type.

    Example: filter_void_tuple_t<int, void, string> = tuple<int, string>

    Example: filter_void_tuple_t<int, void, string> = tuple<int, string>

*/

*/

template<typename T>

template<typename T>

using wrap_non_void_t = std::conditional_t<std::is_void_v<T>, std::tuple<>, std::tuple<T>>;

using wrap_non_void_t = std::conditional_t<std::is_void_v<T>, std::tuple<>, std::tuple<T>>;

template<typename... Ts>

template<typename... Ts>

using filter_void_tuple_t = decltype(std::tuple_cat(std::declval<wrap_non_void_t<Ts>>()...));

using filter_void_tuple_t = decltype(std::tuple_cat(std::declval<wrap_non_void_t<Ts>>()...));

/** 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 - no value storage needed.

/** Specialization for void tasks - no value storage needed.

*/

*/

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<coro, task_count> runner_handles_{};

    std::array<coro, 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

    coro continuation_;

    coro continuation_;

    executor_ref caller_ex_;

    executor_ref caller_ex_;

    {

    {

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

        executor_ref ex_;

        executor_ref ex_;

        std::stop_token stop_token_;

        std::stop_token stop_token_;

        {

        {

        }

        }

        {

        {

        }

        }

        {

        {

            struct awaiter

            struct awaiter

            {

            {

                promise_type* p_;

                promise_type* p_;

                {

                {

                }

                }

                {

                {

                    // Extract everything needed for signaling before

                    // Extract everything needed for signaling before

                    // self-destruction. Inline dispatch may destroy

                    // self-destruction. Inline dispatch may destroy

                    // when_all_state, so we can't access members after.

                    // when_all_state, so we can't access members after.

                    // Self-destruct first - state no longer destroys runners

                    // Self-destruct first - state no longer destroys runners

                    // Signal completion. If last, dispatch parent.

                    // Signal completion. If last, dispatch parent.

                    // Uses only local copies - safe even if state

                    // Uses only local copies - safe even if state

                    // is destroyed during inline dispatch.

                    // is destroyed during inline dispatch.

                {

                {

            };

            };

        }

        }

        {

        {

        {

        {

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

            {

            {

            }

            }

        };

        };

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

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

    Task is passed directly to ensure proper coroutine frame storage.

    Awaitable is passed directly to ensure proper coroutine frame storage.

*/

*/

template<std::size_t Index, typename T, typename... Ts>

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

when_all_runner<T, Ts...>

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

{

{

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

    the concurrent execution of child awaitables.

*/

*/

template<typename... Ts>

template<IoAwaitable... Awaitables>

class when_all_launcher

class when_all_launcher

{

{

    std::tuple<task<Ts>...>* tasks_;

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

    when_all_state<Ts...>* state_;

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

    state_type* state_;

public:

public:

        std::tuple<task<Ts>...>* tasks,

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

        when_all_state<Ts...>* state)

        state_type* state)

    {

    {

    {

    {

    }

    }

    {

    {

        // Forward parent's stop requests to children

        // Forward parent's stop requests to children

        {

        {

                parent_token,

                parent_token,

        }

        }

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

    {

    {

};

};

/** Compute the result type for when_all.

/** Compute the result type for when_all.

    Returns void when all tasks are void (P2300 aligned),

    Returns void when all tasks are void (P2300 aligned),

    otherwise returns a tuple with void types filtered out.

    otherwise returns a tuple with void types filtered out.

*/

*/

template<typename... Ts>

template<typename... Ts>

using when_all_result_t = std::conditional_t<

using when_all_result_t = std::conditional_t<

    std::is_same_v<filter_void_tuple_t<Ts...>, std::tuple<>>,

    std::is_same_v<filter_void_tuple_t<Ts...>, std::tuple<>>,

    void,

    void,

    filter_void_tuple_t<Ts...>>;

    filter_void_tuple_t<Ts...>>;

/** Helper to extract a single result, returning empty tuple for void.

/** Helper to extract a single result, returning empty tuple for void.

    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>

{

{

    using T = std::tuple_element_t<I, std::tuple<Ts...>>;

    using T = std::tuple_element_t<I, std::tuple<Ts...>>;

    if constexpr (std::is_void_v<T>)

    if constexpr (std::is_void_v<T>)

    else

    else

}

}

/** Extract results from state, filtering void types.

/** Extract results from state, filtering void types.

*/

*/

template<typename... Ts>

template<typename... Ts>

{

{

}

}

} // namespace detail

} // namespace detail

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

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

    Launches all tasks 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

    task throws, cancellation is requested for siblings and the first

    awaitable throws, cancellation is requested for siblings and the first

    exception is rethrown after all tasks complete.

    exception is rethrown after all awaitables complete.

    @li All child tasks 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 tasks do not contribute to the result tuple

    @li Void-returning awaitables do not contribute to the result tuple

    @li If all tasks return void, `when_all` returns `task<void>`

    @li If all awaitables return void, `when_all` returns `task<void>`

    @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 tasks execute concurrently but complete through the caller's

    Child awaitables execute concurrently but complete through the caller's

    executor.

    executor.

    @param tasks The tasks to execute concurrently. Each task is

    @param awaitables The awaitables to execute concurrently. Each must

        consumed (moved-from) when `when_all` is awaited.

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

        `when_all` is awaited.

    @return A task yielding a tuple of non-void results. Returns

    @return A task yielding a tuple of non-void results. Returns

        `task<void>` when all input tasks return void.

        `task<void>` when all input awaitables return void.

    @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 tasks don't contribute to result

        // Void awaitables don't contribute to result

        co_await when_all(

        co_await when_all(

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

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

            notify_user( id )      // task<void>

            notify_user( id )      // task<void>

        );

        );

        // Returns task<void>, no result tuple

        // Returns task<void>, no result tuple

    }

    }

    @endcode

    @endcode

    @see task

    @see IoAwaitable, task

*/

*/

template<typename... Ts>

template<IoAwaitable... As>

{

{

    using result_type = detail::when_all_result_t<Ts...>;

    using result_type = detail::when_all_result_t<detail::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<Ts...> state;

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

    // Store tasks in the frame

    // Store awaitables in the frame

    std::tuple<task<Ts>...> task_tuple(std::move(tasks)...);

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

    // Launch all tasks and wait for completion

    // Launch all awaitables and wait for completion

    co_await detail::when_all_launcher<Ts...>(&task_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_);

    // Extract and return results

    // Extract and return results

    if constexpr (std::is_void_v<result_type>)

    if constexpr (std::is_void_v<result_type>)

        co_return;

        co_return;

    else

    else

        co_return detail::extract_results(state);

        co_return detail::extract_results(state);

/// Compute the result type of `when_all` for the given task types.

/// Compute the result type of `when_all` for the given task types.

template<typename... Ts>

template<typename... Ts>

using when_all_result_type = detail::when_all_result_t<Ts...>;

using when_all_result_type = detail::when_all_result_t<Ts...>;

} // namespace capy

} // namespace capy

} // namespace boost

} // namespace boost

#endif

#endif