clocks.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_TIME_CLOCKS_HPP__
#define MSTL_CORE_TIME_CLOCKS_HPP__

 
#include "MSTL/core/time/time_point.hpp"
MSTL_BEGIN_NAMESPACE__

 
struct MSTL_API steady_clock;
 

struct MSTL_API system_clock {
    using duration = _MSTL nanoseconds;   
    using rep = duration::rep;            
    using period = duration::period;      
    using time_point = _MSTL time_point<system_clock>; 
 
    static_assert(system_clock::duration::min() < system_clock::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 = _MSTL time_point<system_clock, seconds>;
        return time_cast<system_clock::duration>(TP(time_value));
    }
};
 

struct MSTL_API steady_clock {
    using duration = _MSTL nanoseconds;   
    using rep = duration::rep;            
    using period = duration::period;      
    using time_point = _MSTL 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 _MSTL 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 + _MSTL time_cast<system_clock::duration>(diff);
    }
};

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

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>
MSTL_INLINE17 constexpr bool is_clock_v = is_clock<T>::value;
 // Clocks
 
MSTL_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
 
MSTL_END_THIS_THREAD__
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_TIME_CLOCKS_HPP__