condition_variable.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_CONDITION_VARIABLE_HPP__
#define NEFORCE_CORE_ASYNC_CONDITION_VARIABLE_HPP__

 
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/time/clocks.hpp"
NEFORCE_BEGIN_NAMESPACE__



enum class cv_status {
    success, 
    timeout  
};
 

NEFORCE_BEGIN_INNER__

class NEFORCE_API condition_variable_base {
public:
#ifdef NEFORCE_PLATFORM_WINDOWS
    using native_handle_type = ::CONDITION_VARIABLE; 
#else
    using native_handle_type = ::pthread_cond_t; 
#endif
 
private:
    native_handle_type cond_; 
 
public:
    condition_variable_base();
 
    condition_variable_base(const condition_variable_base&) = delete;
    condition_variable_base& operator=(const condition_variable_base&) = delete;
 
    condition_variable_base(condition_variable_base&&) = default;
    condition_variable_base& operator=(condition_variable_base&&) = default;
 
    ~condition_variable_base();
 
    native_handle_type* native_handle() noexcept { return &cond_; }

    void wait(mutex& mtx);

    cv_status wait_until(mutex& mtx, int64_t sec, int64_t ns);

    cv_status wait_until(mutex& mtx, bool is_monotonic, int64_t sec, int64_t ns);
 

    void notify_one() noexcept;

    void notify_all() noexcept;
};
 
NEFORCE_END_INNER__

class condition_variable {
public:
    using base_type = inner::condition_variable_base;         
    using native_handle_type = base_type::native_handle_type; 
    using clock_type = _NEFORCE steady_clock;                 
 
private:
    base_type cond_; 

    template <typename Dur>
    cv_status __wait_until_impl(unique_lock<mutex>& lock, const time_point<steady_clock, Dur>& util) {
        auto s = util.to_sec();
        const nanoseconds ns(util - s);
        cond_.wait_until(*lock.mutex(), true, s.since_epoch().count(), ns.count());
        return steady_clock::now() < util ? cv_status::success : cv_status::timeout;
    }

    template <typename Dur>
    cv_status __wait_until_impl(unique_lock<mutex>& lock, const time_point<system_clock, Dur>& util) {
        auto sec = util.to_sec();
        const nanoseconds nanosec(util - sec);
        cond_.wait_until(*lock.mutex(), sec.since_epoch().count(), nanosec.count());
        return system_clock::now() < util ? cv_status::success : cv_status::timeout;
    }
 
public:
    condition_variable() = default;

    ~condition_variable() = default;
 
    condition_variable(const condition_variable&) = delete;
    condition_variable& operator=(const condition_variable&) = delete;
 
    condition_variable(condition_variable&& other) = default;
    condition_variable& operator=(condition_variable&& other) = default;

    native_handle_type* native_handle() noexcept { return cond_.native_handle(); }

    void notify_one() noexcept { cond_.notify_one(); }

    void notify_all() noexcept { cond_.notify_all(); }

    void wait(unique_lock<mutex>& lock) { cond_.wait(*lock.mutex()); }

    template <typename Pred>
    void wait(unique_lock<mutex>& lock, Pred pred) {
        while (!pred()) {
            wait(lock);
        }
    }

    template <typename Dur>
    cv_status wait_until(unique_lock<mutex>& lock, const time_point<steady_clock, Dur>& util) {
        return this->__wait_until_impl(lock, util);
    }

    template <typename Dur>
    cv_status wait_until(unique_lock<mutex>& lock, const time_point<system_clock, Dur>& util) {
        return this->__wait_until_impl(lock, util);
    }

    template <typename Clock, typename Dur>
    cv_status wait_until(unique_lock<mutex>& lock, const time_point<Clock, Dur>& util) {
        const typename Clock::time_point entry = Clock::now();
        const auto atime = clock_type::now() + ceil<clock_type::duration>(util - entry);
 
        if (this->__wait_until_impl(lock, atime) == cv_status::success) {
            return cv_status::success;
        }
        if (Clock::now() < util) {
            return cv_status::success;
        }
        return cv_status::timeout;
    }

    template <typename Clock, typename Dur, typename Pred>
    bool wait_until(unique_lock<mutex>& lock, const time_point<Clock, Dur>& util, Pred pred) {
        while (!pred()) {
            if (this->wait_until(lock, util) == cv_status::timeout) {
                return pred();
            }
        }
        return true;
    }

    template <typename Rep, typename Period>
    cv_status wait_for(unique_lock<mutex>& lock, const duration<Rep, Period>& rest) {
        const auto atime = steady_clock::now() + ceil<steady_clock::duration>(rest);
        return this->wait_until(lock, atime);
    }

    template <typename Rep, typename Period, typename Pred>
    bool wait_for(unique_lock<mutex>& lock, const duration<Rep, Period>& rest, Pred pred) {
        const auto atime = steady_clock::now() + ceil<steady_clock::duration>(rest);
        return this->wait_until(lock, atime, _NEFORCE move(pred));
    }
};
 // ConditionVariables
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_CONDITION_VARIABLE_HPP__