duration.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_TIME_DURATION_HPP__
#define MSTL_CORE_TIME_DURATION_HPP__

 
#include "MSTL/core/numeric/ratio.hpp"
#include "MSTL/core/numeric/math.hpp"
MSTL_BEGIN_NAMESPACE__
 
template <typename Rep, typename Period = ratio<1>>
struct duration;
 
template <typename Clock, typename Dur>
struct time_point;

MSTL_BEGIN_INNER__

template <typename CommonT, typename Period1, typename Period2, typename Dummy = void>
struct __duration_common_type {};
 
template <typename CommonT, typename Period1, typename Period2>
struct __duration_common_type<CommonT, Period1, Period2, void_t<typename CommonT::type>> {
private:
    using gcd_numerator = static_gcd<Period1::num, Period2::num>;
    using gcd_denominator = static_gcd<Period1::den, Period2::den>;
    using common_rep = typename CommonT::type;
    using result_ratio = ratio<
        gcd_numerator::value,
        (Period1::den / gcd_denominator::value) * Period2::den
    >;
 
public:
    using type = duration<common_rep, typename result_ratio::type>;
};
 
MSTL_END_INNER__
 
template <typename Rep1, typename Period1, typename Rep2, typename Period2>
struct common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>
    : _INNER __duration_common_type<common_type<Rep1, Rep2>, typename Period1::type, typename Period2::type>
{};
 
template <typename Rep, typename Period>
struct common_type<duration<Rep, Period>, duration<Rep, Period>> {
    using type = duration<common_type_t<Rep>, typename Period::type>;
};
 
template <typename Rep, typename Period>
struct common_type<duration<Rep, Period>> {
    using type = duration<common_type_t<Rep>, typename Period::type>;
};

MSTL_BEGIN_INNER__
 
template <typename ToDur, typename ConvFactor, typename CommonRep, bool NumIsOne = false, bool DenIsOne = false>
struct __duration_cast_impl {
    template <typename Rep, typename Period>
    static constexpr ToDur __cast(const duration<Rep, Period>& value) {
        return ToDur(static_cast<typename ToDur::rep>(static_cast<CommonRep>(value.count())
            * static_cast<CommonRep>(ConvFactor::num) / static_cast<CommonRep>(ConvFactor::den)));
    }
};
 
template <typename ToDur, typename ConvFactor, typename CommonRep>
struct __duration_cast_impl<ToDur, ConvFactor, CommonRep, true, true> {
    template <typename Rep, typename Period>
    static constexpr ToDur __cast(const duration<Rep, Period>& value) {
        return ToDur(static_cast<typename ToDur::rep>(value.count()));
    }
};
 
template <typename ToDur, typename ConvFactor, typename CommonRep>
struct __duration_cast_impl<ToDur, ConvFactor, CommonRep, true, false> {
    template <typename Rep, typename Period>
    static constexpr ToDur __cast(const duration<Rep, Period>& value) {
        return ToDur(static_cast<typename ToDur::rep>(
            static_cast<CommonRep>(value.count()) / static_cast<CommonRep>(ConvFactor::den)));
    }
};
 
template <typename ToDur, typename ConvFactor, typename CommonRep>
struct __duration_cast_impl<ToDur, ConvFactor, CommonRep, false, true> {
    template <typename Rep, typename Period>
    static constexpr ToDur __cast(const duration<Rep, Period>& value) {
        return ToDur(static_cast<typename ToDur::rep>(
            static_cast<CommonRep>(value.count()) * static_cast<CommonRep>(ConvFactor::num)));
    }
};
 
MSTL_END_INNER__


template <typename T>
struct is_duration : false_type {};
 
template <typename Rep, typename Period>
struct is_duration<duration<Rep, Period>> : true_type {};

template <typename T>
MSTL_INLINE17 constexpr bool is_duration_v = is_duration<T>::value;
 

template <typename ToDur, typename Rep, typename Period, enable_if_t<is_duration<ToDur>::value, int> = 0>
constexpr ToDur time_cast(const duration<Rep, Period>& value) {
    using to_period = typename ToDur::period;
    using to_rep = typename ToDur::rep;
    using conversion_factor = ratio_divide<Period, to_period>;
    using common_rep = common_type_t<to_rep, Rep, intmax_t>;
    using duration_caster = _INNER __duration_cast_impl<ToDur, conversion_factor, common_rep,
        conversion_factor::num == 1, conversion_factor::den == 1>;
    return duration_caster::__cast(value);
}
 
 
using nanoseconds   = duration<int64_t, nano>;              
using microseconds  = duration<int64_t, micro>;             
using milliseconds  = duration<int64_t, milli>;             
using seconds       = duration<int64_t>;                    
using minutes       = duration<int64_t, ratio<60>>;         
using hours         = duration<int64_t, ratio<3600>>;       
using days          = duration<int64_t, ratio<86400>>;      
using weeks         = duration<int64_t, ratio<604800>>;     
using years         = duration<int64_t, ratio<31556952>>;   
using months        = duration<int64_t, ratio<2629746>>;    
 

template <typename Rep, typename Period>
struct duration {
    static_assert(!is_duration_v<Rep>, "rep cannot be a duration");
    static_assert(is_ratio_v<Period>, "period must be a specialization of ratio");
    static_assert(Period::num > 0, "period must be positive");
 
private:
    template <typename R1, typename R2,
         intmax_t Gcd1 = _MSTL gcd(R1::num, R2::num),
         intmax_t Gcd2 = _MSTL gcd(R1::den, R2::den)>
    using divide = ratio<(R1::num / Gcd1) * (R2::den / Gcd2), (R1::den / Gcd2) * (R2::num / Gcd1)>;

    template <typename Period2>
    using is_harmonic = bool_constant<divide<Period2, Period>::den == 1>;
 
public:
    using rep = Rep;                      
    using period = typename Period::type; 
 
private:
    rep rep_ = _MSTL initialize<rep>();  
 
public:
    constexpr duration() = default;

    duration(const duration&) = default;

    constexpr duration& operator =(const duration&) = default;

    template <typename Rep2, typename = enable_if_t<is_convertible_v<const Rep2&, rep>>>
    constexpr explicit duration(const Rep2& rep2) : rep_(static_cast<rep>(rep2)) {}

    template <typename Rep2, typename Period2, typename Dummy = enable_if_t<
        is_convertible_v<const Rep2&, rep> && (is_floating_point_v<rep> || (is_harmonic<Period2>::value && !is_floating_point_v<Rep2>))>
    >
    constexpr duration(const duration<Rep2, Period2>& dur)
    : rep_(_MSTL time_cast<duration>(dur).count()) {}

    template <typename Clock, typename Dur, typename Dummy = enable_if_t<is_duration_v<Dur>>>
    explicit constexpr duration(time_point<Clock, Dur> tp);
 

    constexpr rep count() const noexcept { return rep_; }

    constexpr duration<common_type_t<rep>, period>
    operator +() const {
        return duration<common_type_t<rep>, period>(rep_);
    }

    constexpr duration<common_type_t<rep>, period>
    operator -() const {
        return duration<common_type_t<rep>, period>(-rep_);
    }

    constexpr duration& operator ++() {
        ++rep_;
        return *this;
    }

    constexpr duration operator ++(int) {
        return duration(rep_++);
    }

    constexpr duration& operator --() {
        --rep_;
        return *this;
    }

    constexpr duration  operator --(int) {
        return duration(rep_--);
    }

    constexpr duration& operator +=(const duration& dur) {
        rep_ += dur.count();
        return *this;
    }

    constexpr duration& operator -=(const duration& dur) {
        rep_ -= dur.count();
        return *this;
    }

    constexpr duration& operator *=(const rep& rhs) {
        rep_ *= rhs;
        return *this;
    }

    constexpr duration& operator /=(const rep& rhs) {
        rep_ /= rhs;
        return *this;
    }

    template <typename U = rep, enable_if_t<!is_floating_point_v<U>, int> = 0>
    constexpr duration& operator %=(const rep& rhs) {
        rep_ %= rhs;
        return *this;
    }

    template <typename U = rep, enable_if_t<!is_floating_point_v<U>, int> = 0>
    constexpr duration& operator %=(const duration& rhs) {
        rep_ %= rhs.count();
        return *this;
    }
 

    static constexpr duration zero() noexcept {
        return duration(rep(0));
    }

    static constexpr duration min() noexcept {
        return duration(numeric_traits<Rep>::lowest());
    }

    static constexpr duration max() noexcept {
        return duration(numeric_traits<Rep>::max());
    }
    
    MSTL_ALWAYS_INLINE duration<Rep, nano> to_nano() const {
        return _MSTL time_cast<nanoseconds>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, micro> to_micro() const {
        return _MSTL time_cast<microseconds>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, milli> to_milli() const {
        return _MSTL time_cast<milliseconds>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep> to_sec() const {
        return _MSTL time_cast<seconds>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, ratio<60>> to_minu() const {
        return _MSTL time_cast<minutes>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, ratio<3600>> to_hour() const {
        return _MSTL time_cast<hours>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, ratio<86400>> to_day() const {
        return _MSTL time_cast<days>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, ratio<604800>> to_week() const {
        return _MSTL time_cast<weeks>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, ratio<31556952>> to_year() const {
        return _MSTL time_cast<years>(*this);
    }
    MSTL_ALWAYS_INLINE duration<Rep, ratio<2629746>> to_month() const {
        return _MSTL time_cast<months>(*this);
    }
};

MSTL_BEGIN_INNER__

template <typename Rep1, typename Rep2,
    typename CommonRep = common_type_t<Rep1, Rep2>>
using __common_rep_t = enable_if_t<is_convertible_v<const Rep2&, CommonRep>, CommonRep>;
 
MSTL_END_INNER__
 

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
operator +(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<duration1, duration2>;
    return common_duration(common_duration(lhs).count() + common_duration(rhs).count());
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
operator -(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<duration1, duration2>;
    return common_duration(common_duration(lhs).count() - common_duration(rhs).count());
}

template <typename Rep1, typename Period, typename Rep2>
constexpr duration<_INNER __common_rep_t<Rep1, Rep2>, Period>
operator *(const duration<Rep1, Period>& value, const Rep2& scalar) {
    using common_duration = duration<common_type_t<Rep1, Rep2>, Period>;
    return common_duration(common_duration(value).count() * scalar);
}

template <typename Rep1, typename Rep2, typename Period>
constexpr duration<_INNER __common_rep_t<Rep2, Rep1>, Period>
operator *(const Rep1& scalar, const duration<Rep2, Period>& value) {
    return value * scalar;
}

template <typename Rep1, typename Period, typename Rep2>
constexpr duration<_INNER __common_rep_t<Rep1, enable_if_t<!is_duration_v<Rep2>, Rep2>>, Period>
operator /(const duration<Rep1, Period>& value, const Rep2& scalar) {
    using common_duration = duration<common_type_t<Rep1, Rep2>, Period>;
    return common_duration(common_duration(value).count() / scalar);
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr common_type_t<Rep1, Rep2>
operator /(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<duration1, duration2>;
    return common_duration(lhs).count() / common_duration(rhs).count();
}

template <typename Rep1, typename Period, typename Rep2>
constexpr duration<_INNER __common_rep_t<Rep1, enable_if_t<!is_duration_v<Rep2>, Rep2>>, Period>
operator %(const duration<Rep1, Period>& value, const Rep2& scalar) {
    using common_duration = duration<common_type_t<Rep1, Rep2>, Period>;
    return common_duration(common_duration(value).count() % scalar);
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
operator %(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<duration1, duration2>;
    return common_duration(common_duration(lhs).count() % common_duration(rhs).count());
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr bool operator ==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<duration1, duration2>;
    return common_duration(lhs).count() == common_duration(rhs).count();
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr bool operator !=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    return !(lhs == rhs);
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr bool operator <(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<duration1, duration2>;
    return common_duration(lhs).count() < common_duration(rhs).count();
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr bool operator <=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    return !(rhs < lhs);
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr bool operator >(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    return rhs < lhs;
}

template <typename Rep1, typename Period1, typename Rep2, typename Period2>
constexpr bool operator >=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs) {
    return !(lhs < rhs);
}
 

template <typename ToDur, typename Rep, typename Period>
MSTL_NODISCARD constexpr enable_if_t<is_duration_v<ToDur>, ToDur>
floor(const duration<Rep, Period>& dur) {
    auto to = time_cast<ToDur>(dur);
    if (to > dur) {
        return to - ToDur{1};
    }
    return to;
}

template <typename ToDur, typename Rep, typename Period>
MSTL_NODISCARD constexpr enable_if_t<is_duration_v<ToDur>, ToDur>
ceil(const duration<Rep, Period>& dur) {
    auto to = time_cast<ToDur>(dur);
    if (to < dur) {
        return to + ToDur{1};
    }
    return to;
}
 // Duration

MSTL_BEGIN_INNER__

template <typename Dur, char... Digits>
constexpr Dur __check_overflow() noexcept {
    using value_type = static_parse_int<Digits...>;
    constexpr typename Dur::rep rep = value_type::value;
    static_assert(
        rep >= 0 && rep == value_type::value,
        "literal value cannot be represented by duration type");
    return Dur(rep);
}
 
MSTL_END_INNER__

MSTL_BEGIN_LITERALS__


constexpr duration<decimal_t, ratio<3600, 1>> operator ""_h(const decimal_t hours) noexcept {
    return duration<decimal_t, ratio<3600, 1>>{hours};
}

template <char... Digits>
constexpr hours operator ""_h() noexcept {
    return _INNER __check_overflow<hours, Digits...>();
}

constexpr duration<decimal_t, ratio<60, 1>> operator ""_min(const decimal_t mins) noexcept {
    return duration<decimal_t, ratio<60,1>>{mins};
}

template <char... Digits>
constexpr minutes operator ""_min() noexcept {
    return _INNER __check_overflow<minutes, Digits...>();
}

constexpr duration<decimal_t> operator ""_s(const decimal_t secs) noexcept {
    return duration<decimal_t>{secs};
}

template <char... Digits>
constexpr seconds operator ""_s() noexcept {
    return _INNER __check_overflow<seconds, Digits...>();
}

constexpr duration<decimal_t, milli> operator ""_ms(const decimal_t msecs) noexcept {
    return duration<decimal_t, milli>{msecs};
}

template <char... Digits>
constexpr milliseconds operator ""_ms() noexcept {
    return _INNER __check_overflow<milliseconds, Digits...>();
}

constexpr duration<decimal_t, micro> operator ""_us(const decimal_t usecs) noexcept {
    return duration<decimal_t, micro>{usecs};
}

template <char... Digits>
constexpr microseconds operator ""_us() noexcept {
    return _INNER __check_overflow<microseconds, Digits...>();
}

constexpr duration<decimal_t, nano> operator ""_ns(const decimal_t nsecs) noexcept {
    return duration<decimal_t, nano>{nsecs};
}

template <char... Digits>
constexpr nanoseconds operator ""_ns() noexcept {
    return _INNER __check_overflow<nanoseconds, Digits...>();
}
 // UserLiterals
 
MSTL_END_LITERALS__

MSTL_BEGIN_INNER__
void MSTL_API sleep_for_aux(int64_t s, int64_t ns);
MSTL_END_INNER__
 
MSTL_BEGIN_THIS_THREAD__


template <typename Rep, typename Period>
void sleep_for(const duration<Rep, Period> time) {
    if (time <= time.zero()) return;
 
#ifdef MSTL_PLATFORM_WINDOWS__
    const nanoseconds ns = time.to_nano();
    _INNER sleep_for_aux(0, ns.count());
#elif defined(MSTL_PLATFORM_LINUX__)
    const seconds s = time.to_sec();
    const nanoseconds ns(time - s);
    _INNER sleep_for_aux(s.count(), ns.count());
#endif
}
 // Thread
 
MSTL_END_THIS_THREAD__
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_TIME_DURATION_HPP__