| // duration.hpp --------------------------------------------------------------// |
| |
| // Copyright 2008 Howard Hinnant |
| // Copyright 2008 Beman Dawes |
| // Copyright 2009-2012 Vicente J. Botet Escriba |
| |
| // Distributed under the Boost Software License, Version 1.0. |
| // See http://www.boost.org/LICENSE_1_0.txt |
| |
| /* |
| |
| This code was derived by Beman Dawes from Howard Hinnant's time2_demo prototype. |
| Many thanks to Howard for making his code available under the Boost license. |
| The original code was modified to conform to Boost conventions and to section |
| 20.9 Time utilities [time] of the C++ committee's working paper N2798. |
| See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2798.pdf. |
| |
| time2_demo contained this comment: |
| |
| Much thanks to Andrei Alexandrescu, |
| Walter Brown, |
| Peter Dimov, |
| Jeff Garland, |
| Terry Golubiewski, |
| Daniel Krugler, |
| Anthony Williams. |
| */ |
| |
| |
| #ifndef BOOST_CHRONO_TIME_POINT_HPP |
| #define BOOST_CHRONO_TIME_POINT_HPP |
| |
| #include <boost/chrono/duration.hpp> |
| #include <iostream> |
| |
| #ifndef BOOST_CHRONO_HEADER_ONLY |
| // this must occur after all of the includes and before any code appears: |
| #include <boost/config/abi_prefix.hpp> // must be the last #include |
| #endif |
| |
| //----------------------------------------------------------------------------// |
| // // |
| // 20.9 Time utilities [time] // |
| // synopsis // |
| // // |
| //----------------------------------------------------------------------------// |
| |
| namespace boost { |
| namespace chrono { |
| |
| template <class Clock, class Duration = typename Clock::duration> |
| class time_point; |
| |
| |
| } // namespace chrono |
| |
| |
| // common_type trait specializations |
| |
| template <class Clock, class Duration1, class Duration2> |
| struct common_type<chrono::time_point<Clock, Duration1>, |
| chrono::time_point<Clock, Duration2> >; |
| |
| |
| //----------------------------------------------------------------------------// |
| // 20.9.2.3 Specializations of common_type [time.traits.specializations] // |
| //----------------------------------------------------------------------------// |
| |
| |
| template <class Clock, class Duration1, class Duration2> |
| struct common_type<chrono::time_point<Clock, Duration1>, |
| chrono::time_point<Clock, Duration2> > |
| { |
| typedef chrono::time_point<Clock, |
| typename common_type<Duration1, Duration2>::type> type; |
| }; |
| |
| |
| |
| namespace chrono { |
| |
| // time_point arithmetic |
| template <class Clock, class Duration1, class Rep2, class Period2> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, |
| typename common_type<Duration1, duration<Rep2, Period2> >::type> |
| operator+( |
| const time_point<Clock, Duration1>& lhs, |
| const duration<Rep2, Period2>& rhs); |
| template <class Rep1, class Period1, class Clock, class Duration2> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, |
| typename common_type<duration<Rep1, Period1>, Duration2>::type> |
| operator+( |
| const duration<Rep1, Period1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| template <class Clock, class Duration1, class Rep2, class Period2> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, |
| typename common_type<Duration1, duration<Rep2, Period2> >::type> |
| operator-( |
| const time_point<Clock, Duration1>& lhs, |
| const duration<Rep2, Period2>& rhs); |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| typename common_type<Duration1, Duration2>::type |
| operator-( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, |
| Duration2>& rhs); |
| |
| // time_point comparisons |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool operator==( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool operator!=( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool operator< ( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool operator<=( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool operator> ( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool operator>=( |
| const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs); |
| |
| // time_point_cast |
| template <class ToDuration, class Clock, class Duration> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t); |
| |
| //----------------------------------------------------------------------------// |
| // // |
| // 20.9.4 Class template time_point [time.point] // |
| // // |
| //----------------------------------------------------------------------------// |
| |
| template <class Clock, class Duration> |
| class time_point |
| { |
| BOOST_CHRONO_STATIC_ASSERT(boost::chrono::detail::is_duration<Duration>::value, |
| BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION, (Duration)); |
| public: |
| typedef Clock clock; |
| typedef Duration duration; |
| typedef typename duration::rep rep; |
| typedef typename duration::period period; |
| typedef Duration difference_type; |
| |
| private: |
| duration d_; |
| |
| public: |
| BOOST_FORCEINLINE BOOST_CONSTEXPR |
| time_point() : d_(duration::zero()) |
| {} |
| BOOST_FORCEINLINE BOOST_CONSTEXPR |
| explicit time_point(const duration& d) |
| : d_(d) |
| {} |
| |
| // conversions |
| template <class Duration2> |
| BOOST_FORCEINLINE BOOST_CONSTEXPR |
| time_point(const time_point<clock, Duration2>& t |
| , typename boost::enable_if |
| < |
| boost::is_convertible<Duration2, duration> |
| >::type* = 0 |
| ) |
| : d_(t.time_since_epoch()) |
| { |
| } |
| // observer |
| |
| BOOST_CONSTEXPR |
| duration time_since_epoch() const |
| { |
| return d_; |
| } |
| |
| // arithmetic |
| |
| #ifdef BOOST_CHRONO_EXTENSIONS |
| BOOST_CONSTEXPR |
| time_point operator+() const {return *this;} |
| BOOST_CONSTEXPR |
| time_point operator-() const {return time_point(-d_);} |
| time_point& operator++() {++d_; return *this;} |
| time_point operator++(int) {return time_point(d_++);} |
| time_point& operator--() {--d_; return *this;} |
| time_point operator--(int) {return time_point(d_--);} |
| |
| time_point& operator+=(const rep& r) {d_ += duration(r); return *this;} |
| time_point& operator-=(const rep& r) {d_ -= duration(r); return *this;} |
| |
| #endif |
| |
| time_point& operator+=(const duration& d) {d_ += d; return *this;} |
| time_point& operator-=(const duration& d) {d_ -= d; return *this;} |
| |
| // special values |
| |
| static BOOST_CHRONO_LIB_CONSTEXPR time_point |
| min BOOST_PREVENT_MACRO_SUBSTITUTION () |
| { |
| return time_point((duration::min)()); |
| } |
| static BOOST_CHRONO_LIB_CONSTEXPR time_point |
| max BOOST_PREVENT_MACRO_SUBSTITUTION () |
| { |
| return time_point((duration::max)()); |
| } |
| }; |
| |
| //----------------------------------------------------------------------------// |
| // 20.9.4.5 time_point non-member arithmetic [time.point.nonmember] // |
| //----------------------------------------------------------------------------// |
| |
| // time_point operator+(time_point x, duration y); |
| |
| template <class Clock, class Duration1, class Rep2, class Period2> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, |
| typename common_type<Duration1, duration<Rep2, Period2> >::type> |
| operator+(const time_point<Clock, Duration1>& lhs, |
| const duration<Rep2, Period2>& rhs) |
| { |
| typedef typename common_type<Duration1, duration<Rep2, Period2> >::type CDuration; |
| typedef time_point< |
| Clock, |
| CDuration |
| > TimeResult; |
| return TimeResult(lhs.time_since_epoch() + CDuration(rhs)); |
| } |
| |
| // time_point operator+(duration x, time_point y); |
| |
| template <class Rep1, class Period1, class Clock, class Duration2> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, |
| typename common_type<duration<Rep1, Period1>, Duration2>::type> |
| operator+(const duration<Rep1, Period1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return rhs + lhs; |
| } |
| |
| // time_point operator-(time_point x, duration y); |
| |
| template <class Clock, class Duration1, class Rep2, class Period2> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, |
| typename common_type<Duration1, duration<Rep2, Period2> >::type> |
| operator-(const time_point<Clock, Duration1>& lhs, |
| const duration<Rep2, Period2>& rhs) |
| { |
| return lhs + (-rhs); |
| } |
| |
| // duration operator-(time_point x, time_point y); |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| typename common_type<Duration1, Duration2>::type |
| operator-(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return lhs.time_since_epoch() - rhs.time_since_epoch(); |
| } |
| |
| //----------------------------------------------------------------------------// |
| // 20.9.4.6 time_point comparisons [time.point.comparisons] // |
| //----------------------------------------------------------------------------// |
| |
| // time_point == |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool |
| operator==(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return lhs.time_since_epoch() == rhs.time_since_epoch(); |
| } |
| |
| // time_point != |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool |
| operator!=(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return !(lhs == rhs); |
| } |
| |
| // time_point < |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool |
| operator<(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return lhs.time_since_epoch() < rhs.time_since_epoch(); |
| } |
| |
| // time_point > |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool |
| operator>(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return rhs < lhs; |
| } |
| |
| // time_point <= |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool |
| operator<=(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return !(rhs < lhs); |
| } |
| |
| // time_point >= |
| |
| template <class Clock, class Duration1, class Duration2> |
| inline BOOST_CONSTEXPR |
| bool |
| operator>=(const time_point<Clock, Duration1>& lhs, |
| const time_point<Clock, Duration2>& rhs) |
| { |
| return !(lhs < rhs); |
| } |
| |
| //----------------------------------------------------------------------------// |
| // 20.9.4.7 time_point_cast [time.point.cast] // |
| //----------------------------------------------------------------------------// |
| |
| template <class ToDuration, class Clock, class Duration> |
| inline BOOST_CONSTEXPR |
| time_point<Clock, ToDuration> |
| time_point_cast(const time_point<Clock, Duration>& t) |
| { |
| return time_point<Clock, ToDuration>( |
| duration_cast<ToDuration>(t.time_since_epoch())); |
| } |
| |
| } // namespace chrono |
| } // namespace boost |
| |
| #ifndef BOOST_CHRONO_HEADER_ONLY |
| // the suffix header occurs after all of our code: |
| #include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas |
| #endif |
| |
| #endif // BOOST_CHRONO_TIME_POINT_HPP |