Class ConditionVariable

quantum/quantum_condition_variable.h:36–241

============================================================================================== class ConditionVariable ============================================================================================== @class ConditionVariable @brief This class represents a coroutine-compatible implementation of the std::condition_variable. Most methods of the latter have been recreated with the same b

///        Most methods of the latter have been recreated with the same behavior. This object will yield
///        instead of blocking if called from a coroutine.
class ConditionVariable
{
public:
    /// @brief Default constructor.
    ConditionVariable();
    
    /// @warning Copy constructor is explicitly deleted.
    ConditionVariable(const ConditionVariable& other) = delete;
    
    /// @warning Move constructor is explicitly deleted.
    ConditionVariable(ConditionVariable&& other) = delete;
    
    /// @warning Assignment operator is explicitly deleted.
    ConditionVariable& operator=(const ConditionVariable& other) = delete;
    
    /// @warning Move assignment operator is explicitly deleted.
    ConditionVariable& operator=(ConditionVariable&& other) = delete;
    
    /// @brief Destructor.
    /// @warning Deleting this object while there are still waiting threads results in undefined behavior. Ensure that
    ///          all threads have been notified before doing so. Once the destructor is called, no other wait attempts
    ///          should be made on this object.
    ~ConditionVariable();
    
    /// @brief Notify one waiting thread or coroutine.
    void notifyOne();
    
    /// @brief Notify one waiting thread or coroutine.
    /// @param[in] sync Pointer to a coroutine synchronization object.
    void notifyOne(ICoroSync::Ptr sync);
    
    /// @brief Notify all waiting threads and coroutines.
    void notifyAll();
    
    /// @brief Notify all waiting threads and coroutines.
    /// @param[in] sync Pointer to a coroutine synchronization object.
    void notifyAll(ICoroSync::Ptr sync);
    
    /// @brief Block the current thread until the condition is signalled via notifyOne() or notifyAll().
    /// @details When this function returns, the mutex is guaranteed to be locked.
    /// @param[in] mutex Mutex object which is locked by the current thread.
    /// @note This function should be called from a regular thread not from a coroutine.
    void wait(Mutex& mutex);
    
    /// @brief Yield the current coroutine until the condition is signalled via notifyOne() or notifyAll().
    /// @details When this function returns, the mutex is guaranteed to be locked.
    /// @param[in] sync Pointer to a coroutine synchronization object.
    /// @param[in] mutex Mutex object which is locked by the current coroutine.
    /// @note This function should be called from a coroutine.
    void wait(ICoroSync::Ptr sync,
              Mutex& mutex);
    
    /// @brief Block the current thread until the condition is signalled via notifyOne() or notifyAll().
    /// @details When this function returns, the mutex is guaranteed to be locked. This function calls wait() in a loop
    ///          until the predicate returns true. This ensures that the condition has not changed after notifyOne()
    ///          or notifyAll() have been called. The internal logic is equivalent to:
    /// @code
    ///     while(!predicate())