Method wait_for

src/platforms/esp/32/condition_variable_esp32.cpp.hpp:184–232

template<typename Mutex, typename Rep, typename Period>
cv_status ConditionVariableESP32::wait_for(
    unique_lock<Mutex>& lock,
    const std::chrono::duration<Rep, Period>& rel_time) {  // okay std namespace

    FL_ASSERT(lock.owns_lock(), "ConditionVariableESP32::wait_for() called on unlocked lock");

    // Convert duration to milliseconds
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(rel_time);  // okay std namespace

    // Get the mutex from the lock
    Mutex* mtx = lock.mutex();
    FL_ASSERT(mtx != nullptr, "ConditionVariableESP32::wait_for() called with null mutex");

    SemaphoreHandle_t internal_mutex = static_cast<SemaphoreHandle_t>(mMutex);
    QueueHandle_t queue = static_cast<QueueHandle_t>(mWaitQueue);

    // Get current task handle
    TaskHandle_t current_task = xTaskGetCurrentTaskHandle();

    // Add ourselves to the wait queue
    WaitingTask waiter = { current_task, false };

    // Lock internal mutex
    xSemaphoreTake(internal_mutex, portMAX_DELAY);

    // Add to wait queue
    BaseType_t result = xQueueSend(queue, &waiter, 0);
    if (result != pdTRUE) {
        FL_WARN("ConditionVariableESP32: Wait queue full");
        xSemaphoreGive(internal_mutex);
        return cv_status::timeout;
    }

    // Unlock internal mutex
    xSemaphoreGive(internal_mutex);

    // Unlock user mutex before waiting
    lock.unlock();

    // Wait for notification with timeout
    TickType_t ticks = pdMS_TO_TICKS(ms.count());
    u32 notify_value = ulTaskNotifyTake(pdTRUE, ticks);

    // Re-lock user mutex after waking up
    lock.lock();

    // Check if we were notified or timed out
    return (notify_value == 0) ? cv_status::timeout : cv_status::no_timeout;
}

template<typename Mutex, typename Rep, typename Period, typename Predicate>
bool ConditionVariableESP32::wait_for(