duration.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_TIME_DURATION_HPP__
#define NEFORCE_CORE_TIME_DURATION_HPP__

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

NEFORCE_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>;
};
 
NEFORCE_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>;
};

NEFORCE_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)));
    }
};
 
NEFORCE_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>
NEFORCE_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 = _NEFORCE gcd(R1::num, R2::num),
              intmax_t Gcd2 = _NEFORCE 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_ = _NEFORCE 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_(_NEFORCE 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()); }
 
    NEFORCE_ALWAYS_INLINE duration<Rep, nano> to_nano() const { return _NEFORCE time_cast<nanoseconds>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, micro> to_micro() const { return _NEFORCE time_cast<microseconds>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, milli> to_milli() const { return _NEFORCE time_cast<milliseconds>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep> to_sec() const { return _NEFORCE time_cast<seconds>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, ratio<60>> to_minu() const { return _NEFORCE time_cast<minutes>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, ratio<3600>> to_hour() const { return _NEFORCE time_cast<hours>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, ratio<86400>> to_day() const { return _NEFORCE time_cast<days>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, ratio<604800>> to_week() const { return _NEFORCE time_cast<weeks>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, ratio<31556952>> to_year() const { return _NEFORCE time_cast<years>(*this); }
    NEFORCE_ALWAYS_INLINE duration<Rep, ratio<2629746>> to_month() const { return _NEFORCE time_cast<months>(*this); }
};

NEFORCE_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>;
 
NEFORCE_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>
NEFORCE_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>
NEFORCE_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

NEFORCE_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);
}
 
NEFORCE_END_INNER__

NEFORCE_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
 
NEFORCE_END_LITERALS__

NEFORCE_BEGIN_INNER__
 
void NEFORCE_API sleep_for_aux(ssize_t s, ssize_t ns);
 
NEFORCE_END_INNER__
 
NEFORCE_BEGIN_THIS_THREAD__


template <typename Rep, typename Period>
void sleep_for(const duration<Rep, Period> time) {
    if (time <= time.zero()) {
        return;
    }
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    const nanoseconds ns = time.to_nano();
    inner::sleep_for_aux(0, ns.count());
#elif defined(NEFORCE_PLATFORM_LINUX)
    const seconds s = time.to_sec();
    const nanoseconds ns(time - s);
    inner::sleep_for_aux(s.count(), ns.count());
#endif
}
 // Thread
 
NEFORCE_END_THIS_THREAD__
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_TIME_DURATION_HPP__