Condition.hxx

#pragma once
 
// Linux
#include <pthread.h>
 
// C++
#include <cassert>
 
// cosmos
#include <cosmos/thread/Mutex.hxx>
#include <cosmos/time/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API Condition {
        // disallow copy-assignment
        Condition(const Condition&) = delete;
        Condition& operator=(const Condition&) = delete;
 
public: // types
 
        enum class WaitTimedRes {
                TIMED_OUT,
                SIGNALED
        };
 
public: // functions
 
 
        explicit Condition(Mutex &lock);
 
        ~Condition() {
                const auto destroy_res = ::pthread_cond_destroy(&m_pcond);
 
                assert (!destroy_res);
                (void)destroy_res;
        }
 
 
        void wait() const {
                auto res = ::pthread_cond_wait(&m_pcond, &(m_lock.m_pmutex));
 
                if (auto err = Errno{res}; err != Errno::NO_ERROR) {
                        cosmos_throw (ApiError("pthread_cond_wait()", Errno{err}));
                }
        }
 
 
        WaitTimedRes waitTimed(const MonotonicTime ts) const {
                auto res = ::pthread_cond_timedwait(&m_pcond, &(m_lock.m_pmutex), &ts);
 
                switch(Errno{res}) {
                default: cosmos_throw (ApiError("pthread_cond_timedwait()", Errno{res})); return WaitTimedRes::TIMED_OUT; /* just to silence compiler warning */
                case Errno::NO_ERROR: return WaitTimedRes::SIGNALED;
                case Errno::TIMEDOUT: return WaitTimedRes::TIMED_OUT;
                }
        }
 
 
        void signal() {
                auto res = ::pthread_cond_signal(&m_pcond);
 
                if (auto err = Errno{res}; err != Errno::NO_ERROR) {
                        cosmos_throw (ApiError("pthread_cond_signal()", err));
                }
        }
 
 
        void broadcast() {
                auto res = ::pthread_cond_broadcast(&m_pcond);
 
                if (auto err = Errno{res}; err != Errno::NO_ERROR) {
                        cosmos_throw (ApiError("pthread_cond_broadcast()", err));
                }
        }
 
        Mutex& mutex() { return m_lock; }
 
protected: // data
 
        // mutable to allow const semantics in wait*()
        mutable pthread_cond_t m_pcond;
        Mutex &m_lock;
};
 
class ConditionMutex :
                public Mutex,
                public Condition {
public: // functions
 
        ConditionMutex() :
                Condition{static_cast<Mutex&>(*this)}
        {}
};
 
} // end ns