clocks.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_TIME_CLOCKS_HPP__
#define NEFORCE_CORE_TIME_CLOCKS_HPP__

 
#include "NeForce/core/time/time_point.hpp"
NEFORCE_BEGIN_NAMESPACE__

 
struct NEFORCE_API steady_clock;
 

struct NEFORCE_API system_clock {
    using duration = nanoseconds;                         
    using rep = duration::rep;                            
    using period = duration::period;                      
    using time_point = _NEFORCE time_point<system_clock>; 
 
    static_assert(duration::min() < duration::zero(), "a clock's minimum duration cannot be less than its epoch");

    static constexpr bool is_steady = false;

    static time_point now() noexcept;

    static seconds to_seconds(const time_point& time_point_value) noexcept {
        return time_point_value.since_epoch().to_sec();
    }

    static time_point from_seconds(const seconds time_value) noexcept {
        using TP = _NEFORCE time_point<system_clock, seconds>;
        return time_cast<duration>(TP(time_value));
    }
};
 

struct NEFORCE_API steady_clock {
    using duration = nanoseconds;                         
    using rep = duration::rep;                            
    using period = duration::period;                      
    using time_point = _NEFORCE time_point<steady_clock>; 

    static constexpr bool is_steady = true;

    static time_point now() noexcept;

    template <typename Dur>
    static system_clock::time_point to_system(const _NEFORCE time_point<steady_clock, Dur>& tp) {
        const auto steady_now = steady_clock::now();
        const auto sys_now = system_clock::now();
 
        const auto diff = tp - steady_now;
        return sys_now + _NEFORCE time_cast<system_clock::duration>(diff);
    }
};

milliseconds NEFORCE_API relative_time(int64_t sec, int64_t nsec, bool is_monotonic = false) noexcept;
 

template <typename T>
struct is_clock;
 
template <>
struct is_clock<system_clock> : true_type {};
 
template <>
struct is_clock<steady_clock> : true_type {};

template <typename T>
NEFORCE_INLINE17 constexpr bool is_clock_v = is_clock<T>::value;
 // Clocks
 
NEFORCE_BEGIN_THIS_THREAD__


template <typename Clock, typename Dur>
void sleep_until(const time_point<Clock, Dur>& time) {
    auto current = Clock::now();
    if (Clock::is_steady) {
        if (current < time) {
            this_thread::sleep_for(time - current);
        }
        return;
    }
    while (current < time) {
        this_thread::sleep_for(time - current);
        current = Clock::now();
    }
}
 // Thread
 
NEFORCE_END_THIS_THREAD__
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_TIME_CLOCKS_HPP__