time_point.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_TIME_TIME_POINT_HPP__
#define NEFORCE_CORE_TIME_TIME_POINT_HPP__

 
#include "NeForce/core/time/duration.hpp"
NEFORCE_BEGIN_NAMESPACE__
 
template <typename Clock, typename Dur = typename Clock::duration>
struct time_point;

NEFORCE_BEGIN_INNER__

template <typename CommonT, typename Clock, typename Dummy = void>
struct __timepoint_common_type {};
 
template <typename CommonT, typename Clock>
struct __timepoint_common_type<CommonT, Clock, void_t<typename CommonT::type>> {
    using type = time_point<Clock, typename CommonT::type>;
};
 
NEFORCE_END_INNER__
 
template <typename Clock, typename Dur1, typename Dur2>
struct common_type<time_point<Clock, Dur1>, time_point<Clock, Dur2>>
: inner::__timepoint_common_type<common_type<Dur1, Dur2>, Clock> {};
 
template <typename Clock, typename Dur>
struct common_type<time_point<Clock, Dur>, time_point<Clock, Dur>> {
    using type = time_point<Clock, Dur>;
};
 
template <typename Clock, typename Dur>
struct common_type<time_point<Clock, Dur>> {
    using type = time_point<Clock, Dur>;
};


template <typename ToDur, typename Clock, typename Dur, enable_if_t<is_duration_v<ToDur>, int> = 0>
constexpr time_point<Clock, ToDur> time_cast(const time_point<Clock, Dur>& time_point_value) {
    return time_point<Clock, ToDur>(_NEFORCE time_cast<ToDur>(time_point_value.since_epoch()));
}

template <typename Clock, typename Dur>
struct time_point {
    static_assert(is_duration_v<Dur>, "duration must be a specialization of duration");
 
    using clock_type = Clock;                      
    using duration_type = Dur;                     
    using rep = typename duration_type::rep;       
    using period = typename duration_type::period; 
 
private:
    duration_type value_; 
 
public:
    constexpr time_point() :
    value_(duration_type::zero()) {}

    constexpr explicit time_point(const duration_type& dur) :
    value_(dur) {}

    template <typename Dur2, typename = enable_if_t<is_convertible_v<Dur2, duration_type>>>
    constexpr time_point(const time_point<clock_type, Dur2>& value) :
    value_(value.value_) {}
 

    constexpr time_point& operator++() {
        ++value_;
        return *this;
    }

    constexpr time_point operator++(int) { return time_point{value_++}; }

    constexpr time_point& operator--() {
        --value_;
        return *this;
    }

    constexpr time_point operator--(int) { return time_point{value_--}; }
 

    constexpr time_point& operator+=(const duration_type& dur) {
        value_ += dur;
        return *this;
    }

    constexpr time_point& operator-=(const duration_type& dur) {
        value_ -= dur;
        return *this;
    }

    constexpr duration_type since_epoch() const noexcept { return value_; }

    static constexpr time_point min() noexcept { return time_point(duration_type::min()); }

    static constexpr time_point max() noexcept { return time_point(duration_type::max()); }
 
    NEFORCE_ALWAYS_INLINE time_point<Clock, nanoseconds> to_nano() const {
        return _NEFORCE time_cast<nanoseconds>(*this);
    }
    NEFORCE_ALWAYS_INLINE time_point<Clock, microseconds> to_micro() const {
        return _NEFORCE time_cast<microseconds>(*this);
    }
    NEFORCE_ALWAYS_INLINE time_point<Clock, milliseconds> to_milli() const {
        return _NEFORCE time_cast<milliseconds>(*this);
    }
    NEFORCE_ALWAYS_INLINE time_point<Clock, seconds> to_sec() const { return _NEFORCE time_cast<seconds>(*this); }
    NEFORCE_ALWAYS_INLINE time_point<Clock, minutes> to_minu() const { return _NEFORCE time_cast<minutes>(*this); }
    NEFORCE_ALWAYS_INLINE time_point<Clock, hours> to_hour() const { return _NEFORCE time_cast<hours>(*this); }
    NEFORCE_ALWAYS_INLINE time_point<Clock, days> to_day() const { return _NEFORCE time_cast<days>(*this); }
    NEFORCE_ALWAYS_INLINE time_point<Clock, weeks> to_week() const { return _NEFORCE time_cast<weeks>(*this); }
    NEFORCE_ALWAYS_INLINE time_point<Clock, years> to_year() const { return _NEFORCE time_cast<years>(*this); }
    NEFORCE_ALWAYS_INLINE time_point<Clock, months> to_month() const { return _NEFORCE time_cast<months>(*this); }
};
 
template <typename Rep, typename Period>
template <typename Clock, typename Dur, typename Dummy>
constexpr duration<Rep, Period>::duration(time_point<Clock, Dur> tp) :
duration(_NEFORCE time_cast<Dur>(tp.since_epoch())) {}

template <typename Clock, typename Dur1, typename Rep2, typename Period2>
constexpr time_point<Clock, common_type_t<Dur1, duration<Rep2, Period2>>>
operator+(const time_point<Clock, Dur1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<Dur1, duration2>;
    using result_time_point = time_point<Clock, common_duration>;
    return result_time_point(lhs.since_epoch() + rhs);
}

template <typename Rep1, typename Period1, typename Clock, typename Dur2>
constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Dur2>>
operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Dur2>& rhs) {
    using duration1 = duration<Rep1, Period1>;
    using common_duration = common_type_t<duration1, Dur2>;
    using result_time_point = time_point<Clock, common_duration>;
    return result_time_point(rhs.since_epoch() + lhs);
}

template <typename Clock, typename Dur1, typename Rep2, typename Period2>
constexpr time_point<Clock, common_type_t<Dur1, duration<Rep2, Period2>>>
operator-(const time_point<Clock, Dur1>& lhs, const duration<Rep2, Period2>& rhs) {
    using duration2 = duration<Rep2, Period2>;
    using common_duration = common_type_t<Dur1, duration2>;
    using result_time_point = time_point<Clock, common_duration>;
    return result_time_point(lhs.since_epoch() - rhs);
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr common_type_t<Dur1, Dur2> operator-(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return lhs.since_epoch() - rhs.since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr bool operator==(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return lhs.since_epoch() == rhs.since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr bool operator!=(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return !(lhs == rhs);
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr bool operator<(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return lhs.since_epoch() < rhs.since_epoch();
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr bool operator<=(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return !(rhs < lhs);
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr bool operator>(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return rhs < lhs;
}

template <typename Clock, typename Dur1, typename Dur2>
constexpr bool operator>=(const time_point<Clock, Dur1>& lhs, const time_point<Clock, Dur2>& rhs) {
    return !(lhs < rhs);
}
 // TimePoint
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_TIME_TIME_POINT_HPP__