Method lock_impl

source/threads/async_lock.cpp:44–89

}

concurrencpp::lazy_result<scoped_async_lock> async_lock::lock_impl(std::shared_ptr<executor> resume_executor, bool with_raii_guard) {
    auto resume_synchronously = true;  // indicates if the locking coroutine managed to lock the lock on first attempt

    while (true) {
        std::unique_lock<std::mutex> lock(m_awaiter_lock);
        if (!m_locked) {
            m_locked = true;
            lock.unlock();
            break;
        }

        co_await async_lock_awaiter(*this, lock);

        resume_synchronously =
            false;  // if we haven't managed to lock the lock on first attempt, we need to resume using resume_executor
    }

    if (!resume_synchronously) {
        try {
            co_await resume_on(resume_executor);
        } catch (...) {
            std::unique_lock<std::mutex> lock(m_awaiter_lock);
            assert(m_locked);
            m_locked = false;
            const auto awaiter = m_awaiters.pop_front();
            lock.unlock();

            if (awaiter != nullptr) {
                awaiter->retry();
            }

            throw;
        }
    }

#ifdef CRCPP_DEBUG_MODE
    const auto current_count = m_thread_count_in_critical_section.fetch_add(1, std::memory_order_relaxed);
    assert(current_count == 0);
#endif

    if (with_raii_guard) {
        co_return scoped_async_lock(*this, std::adopt_lock);
    }

    co_return scoped_async_lock(*this, std::defer_lock);
}

concurrencpp::lazy_result<scoped_async_lock> async_lock::lock(std::shared_ptr<executor> resume_executor) {
    if (!static_cast<bool>(resume_executor)) {