ConditionVariable.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Threading/Mutex.hpp"
#include "Arp/System/Commons/Chrono/TimePoint.hpp"
 
namespace Arp { namespace System { namespace Ve
{
class ICondVariableService;
}}};
 
namespace Arp { namespace System { namespace Commons { namespace Threading
{
 
using namespace Arp::System::Commons::Chrono;
 
class ConditionVariable
{
public: // construction/destruction
    ConditionVariable(void);
 
    ~ConditionVariable(void);
 
public: // operations
 
    template<class Predicate>
    void Wait(Mutex& mutex, Predicate predicate);
 
    template<class Predicate>
    bool WaitFor(Mutex& mutex, unsigned long timeoutMs, Predicate predicate);
 
    template<class Predicate>
    bool WaitUntil(Mutex& mutex, TimePointClockSteady timePoint, Predicate predicate);
 
    void NotifyOne(void);
 
    void NotifyAll(void);
 
private: // methods
    void WaitInternal(Mutex& mutex);
    bool WaitUntilInternal(Mutex& mutex, TimePointClockSteady timePoint);
 
private: // deleted methods
    ConditionVariable(const ConditionVariable& arg) = delete;
 
    ConditionVariable& operator=(const ConditionVariable& arg) = delete;
 
private: // fields
    Arp::System::Ve::ICondVariableService *pCondVariableService;
};
 
// inline methods of class ConditionVariable
template<class Predicate>
void ConditionVariable::Wait(Mutex& mutex, Predicate predicate)
{
    while (!predicate())
    {
        WaitInternal(mutex);
    }
}
 
template<class Predicate>
bool ConditionVariable::WaitFor(Mutex& mutex, unsigned long timeoutMs, Predicate predicate)
{
    SteadyTimePoint now = SteadyClock::now();
    SteadyTimePoint timePoint = now + Milliseconds(timeoutMs);
 
    return WaitUntil(mutex, timePoint, predicate);
}
 
template<class Predicate>
bool ConditionVariable::WaitUntil(Mutex& mutex, TimePointClockSteady timePoint, Predicate predicate)
{
    bool result = true;
    while ((!predicate()) && result)
    {
        result = WaitUntilInternal(mutex, timePoint);
    }
 
    // https://www.man7.org/linux/man-pages/man3/pthread_cond_timedwait.3p.html
    // Condition Wait Semantics
    //    Similarly, when
    //    pthread_cond_timedwait() returns with the timeout error, the
    //    associated predicate may be true due to an unavoidable race
    //    between the expiration of the timeoutand the predicate state
    //    change.
    return predicate();
}
 
}}}} // end of namespace Arp::System::Commons::Threading