Diff coverage report for

//

//

// Copyright (c) 2026 Michael Vandeberg

// Copyright (c) 2026 Michael Vandeberg

//

//

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

#ifndef BOOST_CAPY_DELAY_HPP

#define BOOST_CAPY_DELAY_HPP

#define BOOST_CAPY_DELAY_HPP

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

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

#include <boost/capy/error.hpp>

#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/ex/detail/timer_service.hpp>

#include <boost/capy/ex/detail/timer_service.hpp>

#include <boost/capy/io_result.hpp>

#include <atomic>

#include <atomic>

#include <chrono>

#include <chrono>

#include <coroutine>

#include <coroutine>

#include <new>

#include <new>

#include <stop_token>

#include <stop_token>

#include <utility>

#include <utility>

namespace boost {

namespace boost {

namespace capy {

namespace capy {

/** IoAwaitable returned by @ref delay.

/** IoAwaitable returned by @ref delay.

    Suspends the calling coroutine until the deadline elapses

    Suspends the calling coroutine until the deadline elapses

    or the environment's stop token is activated, whichever

    or the environment's stop token is activated, whichever

    comes first. Resumption is always posted through the

    comes first. Resumption is always posted through the

    executor, never inline on the timer thread.

    executor, never inline on the timer thread.

    Not intended to be named directly; use the @ref delay

    Not intended to be named directly; use the @ref delay

    factory function instead.

    factory function instead.

    @par Return Value

    Returns `io_result<>{}` (no error) when the timer fires

    normally, or `io_result<>{error::canceled}` when

    cancellation claims the resume before the deadline.

    @par Cancellation

    @par Cancellation

    If `stop_requested()` is true before suspension, the

    If `stop_requested()` is true before suspension, the

    coroutine resumes immediately without scheduling a timer.

    coroutine resumes immediately without scheduling a timer

    If stop is requested while suspended, the stop callback

    and returns `io_result<>{error::canceled}`. If stop is

    claims the resume and posts it through the executor; the

    requested while suspended, the stop callback claims the

    pending timer is cancelled on the next `await_resume` or

    resume and posts it through the executor; the pending

    timer is cancelled on the next `await_resume` or

    destructor call.

    destructor call.

    @par Thread Safety

    @par Thread Safety

    A single `delay_awaitable` must not be awaited concurrently.

    A single `delay_awaitable` must not be awaited concurrently.

    Multiple independent `delay()` calls on the same

    Multiple independent `delay()` calls on the same

    execution_context are safe and share one timer thread.

    execution_context are safe and share one timer thread.

    @see delay, timeout

    @see delay, timeout

*/

*/

class delay_awaitable

class delay_awaitable

{

{

    std::chrono::nanoseconds dur_;

    std::chrono::nanoseconds dur_;

    detail::timer_service* ts_ = nullptr;

    detail::timer_service* ts_ = nullptr;

    detail::timer_service::timer_id tid_ = 0;

    detail::timer_service::timer_id tid_ = 0;

    // Declared before stop_cb_buf_: the callback

    // Declared before stop_cb_buf_: the callback

    // accesses these members, so they must still be

    // accesses these members, so they must still be

    // alive if the stop_cb_ destructor blocks.

    // alive if the stop_cb_ destructor blocks.

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

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

    bool canceled_ = false;

    bool canceled_ = false;

    bool stop_cb_active_ = false;

    bool stop_cb_active_ = false;

    struct cancel_fn

    struct cancel_fn

    {

    {

        delay_awaitable* self_;

        delay_awaitable* self_;

        executor_ref ex_;

        executor_ref ex_;

        std::coroutine_handle<> h_;

        std::coroutine_handle<> h_;

        {

        {

                true, std::memory_order_acq_rel))

                true, std::memory_order_acq_rel))

            {

            {

            }

            }

    };

    };

    using stop_cb_t = std::stop_callback<cancel_fn>;

    using stop_cb_t = std::stop_callback<cancel_fn>;

    // Aligned storage for the stop callback.

    // Aligned storage for the stop callback.

    // Declared last: its destructor may block while

    // Declared last: its destructor may block while

    // the callback accesses the members above.

    // the callback accesses the members above.

    BOOST_CAPY_MSVC_WARNING_PUSH

    BOOST_CAPY_MSVC_WARNING_PUSH

    BOOST_CAPY_MSVC_WARNING_DISABLE(4324)

    BOOST_CAPY_MSVC_WARNING_DISABLE(4324)

    alignas(stop_cb_t)

    alignas(stop_cb_t)

        unsigned char stop_cb_buf_[sizeof(stop_cb_t)];

        unsigned char stop_cb_buf_[sizeof(stop_cb_t)];

    BOOST_CAPY_MSVC_WARNING_POP

    BOOST_CAPY_MSVC_WARNING_POP

    {

    {

    }

    }

public:

public:

    {

    {

    /// @pre The stop callback must not be active

    /// @pre The stop callback must not be active

    ///      (i.e. the object has not yet been awaited).

    ///      (i.e. the object has not yet been awaited).

    {

    {

    {

    {

    delay_awaitable(delay_awaitable const&) = delete;

    delay_awaitable(delay_awaitable const&) = delete;

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

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

    delay_awaitable& operator=(delay_awaitable&&) = delete;

    delay_awaitable& operator=(delay_awaitable&&) = delete;

    {

    {

    }

    }

    std::coroutine_handle<>

    std::coroutine_handle<>

        std::coroutine_handle<> h,

        std::coroutine_handle<> h,

        io_env const* env) noexcept

        io_env const* env) noexcept

    {

    {

        // Already stopped: resume immediately

        // Already stopped: resume immediately

        {

        {

        }

        }

        // Schedule timer (won't fire inline since deadline is in the future)

        // Schedule timer (won't fire inline since deadline is in the future)

            {

            {

                    true, std::memory_order_acq_rel))

                    true, std::memory_order_acq_rel))

                {

                {

                }

                }

        // Register stop callback (may fire inline)

        // Register stop callback (may fire inline)

    }

    }

    {

    {

        {

        {

        }

        }

};

};

/** Suspend the current coroutine for a duration.

/** Suspend the current coroutine for a duration.

    Returns an IoAwaitable that completes at or after the

    Returns an IoAwaitable that completes at or after the

    specified duration, or earlier if the environment's stop

    specified duration, or earlier if the environment's stop

    token is activated. Completion is always normal (void

    token is activated.

    return); no exception is thrown on cancellation.

    Zero or negative durations complete synchronously without

    Zero or negative durations complete synchronously without

    scheduling a timer.

    scheduling a timer.

    @par Example

    @par Example

    @code

    @code

    co_await delay(std::chrono::milliseconds(100));

    auto [ec] = co_await delay(std::chrono::milliseconds(100));

    @endcode

    @endcode

    @param dur The duration to wait.

    @param dur The duration to wait.

    @return A @ref delay_awaitable whose `await_resume`

    @return A @ref delay_awaitable whose `await_resume`

        returns `void`.

        returns `io_result<>`. On normal completion, `ec`

        is clear. On cancellation, `ec == error::canceled`.

    @throws Nothing.

    @throws Nothing.

    @see timeout, delay_awaitable

    @see timeout, delay_awaitable

*/

*/

template<typename Rep, typename Period>

template<typename Rep, typename Period>

delay_awaitable

delay_awaitable

{

{

    return delay_awaitable{

    return delay_awaitable{

}

}

} // capy

} // capy

} // boost

} // boost

#endif

#endif