Class ClockConditionalVariable

Class Documentation

class ClockConditionalVariable

A synchronization primitive, similar to std::conditional_variable, that works with the rclcpp::Clock.

For more information on the API see https://en.cppreference.com/w/cpp/thread/condition_variable.

This primitive will wake up if the context was shut down.

Public Functions

ClockConditionalVariable(const rclcpp::Clock::SharedPtr &clock, rclcpp::Context::SharedPtr context = rclcpp::contexts::get_global_default_context())
~ClockConditionalVariable()
bool wait_until(std::unique_lock<std::mutex> &lock, rclcpp::Time until, const std::function<bool()> &pred)

Calling this function will block the current thread, until abs_time is reached, or pred returns true.

Parameters:

  • lock – A locked lock. The lock must be locked at call time, or this method will throw. The lock will be atomically released and this thread will blocked. The given lock must be created using the mutex returned my mutex().

  • abs_time – The time until which this thread shall be blocked.

  • pred – may be called in cased of spurious wakeups, but must be called every time notify_one() was called. During the call to pred, the given lock will be locked. This method will return, if pred returns true.

Returns:

true if until was reached.

void notify_one()

Notify the blocked thread, that is should reevaluate the wakeup condition. E.g. the given pred function in wait_until shall be reevaluated.

std::mutex &mutex()

Returns the internal mutex. In order to be race free with the context shutdown, this mutex must be used for the wait_until call.