condition.h

Go to the documentation of this file.

#ifndef CONDITION_H
#define CONDITION_H
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
#include <pthread.h>
#elif ORIGINAL_COMPILER_MSVC
#endif
 
#include "mutex.h"
#include "zeit.h"
 
namespace original
{
    class conditionBase
    {
    public:
        explicit conditionBase() = default;
 
        virtual void wait(mutexBase& mutex) = 0;
 
        virtual bool waitFor(mutexBase& mutex, time::duration d) = 0;
 
        template<typename Pred>
        void wait(mutexBase& mutex, Pred predicate) noexcept(noexcept(predicate()));
 
        template<typename Pred>
        bool waitFor(mutexBase& mutex, const time::duration& d, Pred predicate) noexcept(noexcept(predicate()));
 
        virtual void notify() = 0;
 
        virtual void notifyAll() = 0;
 
        void notifySome(u_integer n);
 
        virtual ~conditionBase() = default;
 
        conditionBase(const conditionBase&) = delete;
 
        conditionBase& operator=(const conditionBase&) = delete;
    };
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
    class pCondition final : public conditionBase
    {
        pthread_cond_t cond_; 
 
    public:
        // Inherit template methods from conditionBase
        using conditionBase::wait;
        using conditionBase::waitFor;
 
        explicit pCondition();
 
        void wait(mutexBase& mutex) override;
 
        bool waitFor(mutexBase& mutex, time::duration d) override;
 
        void notify() override;
 
        void notifyAll() override;
 
        ~pCondition() override;
    };
 
#elif ORIGINAL_COMPILER_MSVC
    class wCondition final : public conditionBase
    {
        CONDITION_VARIABLE cond_;
    public:
        using conditionBase::wait;
        using conditionBase::waitFor;
 
        explicit wCondition();
 
        void wait(mutexBase& mutex) override;
 
        bool waitFor(mutexBase& mutex, time::duration d) override;
 
        void notify() override;
 
        void notifyAll() override;
 
        ~wCondition() override;
    };
#endif
 
    class condition final : public conditionBase {
    #if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
        pCondition cond_;
    #elif ORIGINAL_COMPILER_MSVC
        wCondition cond_;
    #endif
 
    public:
        using conditionBase::wait;
        using conditionBase::waitFor;
 
        condition();
 
        void wait(mutexBase& mutex) override;
 
        bool waitFor(mutexBase& mutex, time::duration d) override;
 
        void notify() override;
 
        void notifyAll() override;
    };
 
}
template<typename Pred>
void original::conditionBase::wait(mutexBase& mutex, Pred predicate) noexcept(noexcept(predicate())) {
    while (!predicate()){
        this->wait(mutex);
    }
}
 
template<typename Pred>
bool original::conditionBase::waitFor(mutexBase& mutex, const time::duration& d, Pred predicate) noexcept(noexcept(predicate())) {
    const time::point start = time::point::now();
    while (!predicate()) {
        auto elapsed = time::point::now() - start;
        if (elapsed >= d)
            return false;
        if (!this->waitFor(mutex, d - elapsed))
            return false;
        if (predicate())
            return true;
    }
    return true;
}
 
inline void original::conditionBase::notifySome(const u_integer n) {
    if (n == 0){
        return;
    }
    if (n == 1){
        this->notify();
    } else {
        this->notifyAll();
    }
}
 
#if ORIGINAL_COMPILER_GCC || ORIGINAL_COMPILER_CLANG
inline original::pCondition::pCondition() : cond_{}
{
    if (const int code = pthread_cond_init(&this->cond_, nullptr); code != 0)
    {
        throw sysError("Failed to initialize condition variable (pthread_cond_init returned " + printable::formatString(code) + ")");
    }
}
 
inline void original::pCondition::wait(mutexBase& mutex)
{
    staticError<valueError, !std::is_same_v<mutex::native_handle, pMutex::native_handle>>::asserts();
 
    const auto handle = static_cast<mutex::native_handle*>(mutex.nativeHandle());
    if (const int code = pthread_cond_wait(&this->cond_, handle); code != 0) {
        throw sysError("Failed to wait on condition variable (pthread_cond_wait returned " + printable::formatString(code) + ")");
    }
}
 
inline bool original::pCondition::waitFor(mutexBase& mutex, const time::duration d)
{
    staticError<valueError, !std::is_same_v<mutex::native_handle, pMutex::native_handle>>::asserts();
 
    const auto deadline = time::point::now() + d;
    const auto ts = deadline.toTimespec();
    const auto handle = static_cast<mutex::native_handle*>(mutex.nativeHandle());
    const int code = pthread_cond_timedwait(&this->cond_, handle, &ts);
    if (code == 0) return true;
    if (code == ETIMEDOUT) return false;
    throw sysError("Failed to timed wait on condition variable (pthread_cond_timed-wait returned " + printable::formatString(code) + ")");
}
 
inline void original::pCondition::notify()
{
    if (const int code = pthread_cond_signal(&this->cond_); code != 0) {
        throw sysError("Failed to signal condition variable (pthread_cond_signal returned " + printable::formatString(code) + ")");
    }
}
 
inline void original::pCondition::notifyAll()
{
    if (const int code = pthread_cond_broadcast(&this->cond_); code != 0) {
        throw sysError("Failed to broadcast condition variable (pthread_cond_broadcast returned " + printable::formatString(code) + ")");
    }
}
 
inline original::pCondition::~pCondition()
{
    if (const int code = pthread_cond_destroy(&this->cond_); code != 0) {
        std::cerr << "Warning: Failed to destroy condition variable (pthread_cond_destroy returned "
                  << code << ")" << std::endl;
    }
}
#elif ORIGINAL_COMPILER_MSVC
inline original::wCondition::wCondition() : cond_{}
{
    InitializeConditionVariable(&this->cond_);
}
 
inline void original::wCondition::wait(mutexBase& mutex)
{
    if (const auto handle = static_cast<mutex::native_handle*>(mutex.nativeHandle());
        !SleepConditionVariableSRW(&this->cond_, handle, INFINITE, 0)) {
        throw sysError("Failed to wait on condition variable (SleepConditionVariableSRW returned error " +
                      printable::formatString(GetLastError()));
    }
}
 
inline bool original::wCondition::waitFor(mutexBase& mutex, const time::duration d)
{
    const auto handle = static_cast<mutex::native_handle*>(mutex.nativeHandle());
    if (const auto timeout_ms = d.toDWMilliseconds();
        !SleepConditionVariableSRW(&this->cond_, handle, timeout_ms, 0)) {
        const DWORD error = GetLastError();
        if (error == ERROR_TIMEOUT) {
            return false;
        }
        throw sysError("Failed to timed wait on condition variable (SleepConditionVariableSRW returned error " +
                      printable::formatString(error));
    }
    return true;
}
 
inline void original::wCondition::notify()
{
    WakeConditionVariable(&this->cond_);
}
 
inline void original::wCondition::notifyAll()
{
    WakeAllConditionVariable(&this->cond_);
}
 
inline original::wCondition::~wCondition() = default;
#endif
 
inline original::condition::condition() = default;
 
inline void original::condition::wait(mutexBase& mutex)
{
    this->cond_.wait(mutex);
}
 
inline bool original::condition::waitFor(mutexBase& mutex, time::duration d)
{
    return this->cond_.waitFor(mutex, d);
}
 
inline void original::condition::notify()
{
    this->cond_.notify();
}
 
inline void original::condition::notifyAll()
{
    this->cond_.notifyAll();
}
 
#endif //CONDITION_H