condition.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_CONDITION_HPP__
#define __JOIN_CONDITION_HPP__
 
// libjoin.
#include <join/mutex.hpp>
#include <join/error.hpp>
#include <join/utils.hpp>
 
// C++.
#include <chrono>
 
namespace join
{
    class Condition
    {
    public:
        Condition ();
 
        Condition (const Condition& other) = delete;
 
        Condition& operator= (const Condition& other) = delete;
 
        Condition (Condition&& other) = delete;
 
        Condition& operator= (Condition&& other) = delete;
 
        ~Condition ();
 
        void signal () noexcept;
 
        void broadcast () noexcept;
 
        template <class Lock>
        void wait (Lock& lock)
        {
            pthread_cond_wait (&_handle, lock.mutex ()->handle ());
        }
 
        template <class Lock, class Predicate>
        void wait (Lock& lock, Predicate pred)
        {
            while (!pred ())
            {
                wait (lock);
            }
        }
 
        template <class Lock, class Rep, class Period>
        bool timedWait (Lock& lock, std::chrono::duration <Rep, Period> timeout)
        {
            struct timespec ts = toTimespec (std::chrono::steady_clock::now () + timeout);
            int err = pthread_cond_timedwait (&_handle, lock.mutex ()->handle (), &ts);
            if (err != 0)
            {
                lastError = std::make_error_code (static_cast <std::errc> (err));
                return false;
            }
            return true;
        }
 
        template <class Lock, class Rep, class Period, class Predicate>
        bool timedWait (Lock& lock, std::chrono::duration <Rep, Period> timeout, Predicate pred)
        {
            struct timespec ts = toTimespec (std::chrono::steady_clock::now () + timeout);
            while (!pred ())
            {
                int err = pthread_cond_timedwait (&_handle, lock.mutex ()->handle (), &ts);
                if (err != 0)
                {
                    lastError = std::make_error_code (static_cast <std::errc> (err));
                    return pred ();
                }
            }
 
            return true;
        }
 
    private:
        pthread_cond_t _handle;
    };
 
    class SharedCondition
    {
    public:
        SharedCondition ();
 
        SharedCondition (const SharedCondition& other) = delete;
 
        SharedCondition& operator= (const SharedCondition& other) = delete;
 
        SharedCondition (SharedCondition&& other) = delete;
 
        SharedCondition& operator= (SharedCondition&& other) = delete;
 
        ~SharedCondition ();
 
        void signal () noexcept;
 
        void broadcast () noexcept;
 
        void wait (ScopedLock <SharedMutex>& lock);
 
        template <class Predicate>
        void wait (ScopedLock <SharedMutex>& lock, Predicate pred)
        {
            while (!pred ())
            {
                wait (lock);
            }
        }
 
        template <class Rep, class Period>
        bool timedWait (ScopedLock <SharedMutex>& lock, std::chrono::duration <Rep, Period> timeout)
        {
            struct timespec ts = toTimespec (std::chrono::steady_clock::now () + timeout);
            int err = pthread_cond_timedwait (&_handle, lock.mutex ()->handle (), &ts);
            if (err != 0)
            {
                lastError = std::make_error_code (static_cast <std::errc> (err));
                return false;
            }
 
            return true;
        }
 
        template <class Rep, class Period, class Predicate>
        bool timedWait (ScopedLock <SharedMutex>& lock, std::chrono::duration <Rep, Period> timeout, Predicate pred)
        {
            struct timespec ts = toTimespec (std::chrono::steady_clock::now () + timeout);
            while (!pred ())
            {
                int err = pthread_cond_timedwait (&_handle, lock.mutex ()->handle (), &ts);
                if (err != 0)
                {
                    lastError = std::make_error_code (static_cast <std::errc> (err));
                    return pred ();
                }
            }
 
            return true;
        }
 
    private:
        pthread_cond_t _handle;
    };
}
 
#endif