Class delay_object_awaitable

source/timers/timer_queue.cpp:277–310

                                                                    std::shared_ptr<concurrencpp::timer_queue> self,
                                                                    std::shared_ptr<concurrencpp::executor> executor) {
    class delay_object_awaitable : public details::suspend_always {

       private:
        const size_t m_due_time_ms;
        timer_queue& m_parent_queue;
        std::shared_ptr<concurrencpp::executor> m_executor;
        bool m_interrupted = false;

       public:
        delay_object_awaitable(size_t due_time_ms,
                               timer_queue& parent_queue,
                               std::shared_ptr<concurrencpp::executor> executor) noexcept :
            m_due_time_ms(due_time_ms),
            m_parent_queue(parent_queue), m_executor(std::move(executor)) {}

        void await_suspend(details::coroutine_handle<void> coro_handle) noexcept {
            try {
                m_parent_queue.make_timer_impl(m_due_time_ms,
                                               0,
                                               std::move(m_executor),
                                               true,
                                               details::await_via_functor {coro_handle, &m_interrupted});

            } catch (...) {
                // do nothing. ~await_via_functor will resume the coroutine and throw an exception.
            }
        }

        void await_resume() const {
            if (m_interrupted) {
                throw errors::broken_task(details::consts::k_broken_task_exception_error_msg);
            }
        }
    };

    co_await delay_object_awaitable {static_cast<size_t>(due_time.count()), *this, std::move(executor)};
}