diff options
Diffstat (limited to 'contrib/libc++/include/chrono')
| -rw-r--r-- | contrib/libc++/include/chrono | 875 |
1 files changed, 875 insertions, 0 deletions
diff --git a/contrib/libc++/include/chrono b/contrib/libc++/include/chrono new file mode 100644 index 0000000..0571f9d --- /dev/null +++ b/contrib/libc++/include/chrono @@ -0,0 +1,875 @@ +// -*- C++ -*- +//===---------------------------- chrono ----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_CHRONO +#define _LIBCPP_CHRONO + +/* + chrono synopsis + +namespace std +{ +namespace chrono +{ + +template <class ToDuration, class Rep, class Period> +ToDuration +duration_cast(const duration<Rep, Period>& fd); + +template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {}; + +template <class Rep> +struct duration_values +{ +public: + static Rep zero(); + static Rep max(); + static Rep min(); +}; + +// duration + +template <class Rep, class Period = ratio<1>> +class duration +{ + static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration"); + static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio"); + static_assert(Period::num > 0, "duration period must be positive"); +public: + typedef Rep rep; + typedef Period period; + + duration() = default; + template <class Rep2> + explicit duration(const Rep2& r, + typename enable_if + < + is_convertible<Rep2, rep>::value && + (treat_as_floating_point<rep>::value || + !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value) + >::type* = 0); + + // conversions + template <class Rep2, class Period2> + duration(const duration<Rep2, Period2>& d, + typename enable_if + < + treat_as_floating_point<rep>::value || + ratio_divide<Period2, period>::type::den == 1 + >::type* = 0); + + // observer + + rep count() const; + + // arithmetic + + duration operator+() const; + duration operator-() const; + duration& operator++(); + duration operator++(int); + duration& operator--(); + duration operator--(int); + + duration& operator+=(const duration& d); + duration& operator-=(const duration& d); + + duration& operator*=(const rep& rhs); + duration& operator/=(const rep& rhs); + + // special values + + static duration zero(); + static duration min(); + static duration max(); +}; + +typedef duration<long long, nano> nanoseconds; +typedef duration<long long, micro> microseconds; +typedef duration<long long, milli> milliseconds; +typedef duration<long long > seconds; +typedef duration< long, ratio< 60> > minutes; +typedef duration< long, ratio<3600> > hours; + +template <class Clock, class Duration = typename Clock::duration> +class time_point +{ +public: + typedef Clock clock; + typedef Duration duration; + typedef typename duration::rep rep; + typedef typename duration::period period; +private: + duration d_; // exposition only + +public: + time_point(); // has value "epoch" + explicit time_point(const duration& d); // same as time_point() + d + + // conversions + template <class Duration2> + time_point(const time_point<clock, Duration2>& t); + + // observer + + duration time_since_epoch() const; + + // arithmetic + + time_point& operator+=(const duration& d); + time_point& operator-=(const duration& d); + + // special values + + static constexpr time_point min(); + static constexpr time_point max(); +}; + +} // chrono + +// common_type traits +template <class Rep1, class Period1, class Rep2, class Period2> + struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>; + +template <class Clock, class Duration1, class Duration2> + struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>; + +namespace chrono { + +// duration arithmetic +template <class Rep1, class Period1, class Rep2, class Period2> + typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type + operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period1, class Rep2, class Period2> + typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type + operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period, class Rep2> + duration<typename common_type<Rep1, Rep2>::type, Period> + operator*(const duration<Rep1, Period>& d, const Rep2& s); +template <class Rep1, class Period, class Rep2> + duration<typename common_type<Rep1, Rep2>::type, Period> + operator*(const Rep1& s, const duration<Rep2, Period>& d); +template <class Rep1, class Period, class Rep2> + duration<typename common_type<Rep1, Rep2>::type, Period> + operator/(const duration<Rep1, Period>& d, const Rep2& s); +template <class Rep1, class Period1, class Rep2, class Period2> + typename common_type<Rep1, Rep2>::type + operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +// duration comparisons +template <class Rep1, class Period1, class Rep2, class Period2> + bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period1, class Rep2, class Period2> + bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period1, class Rep2, class Period2> + bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period1, class Rep2, class Period2> + bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period1, class Rep2, class Period2> + bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); +template <class Rep1, class Period1, class Rep2, class Period2> + bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +// duration_cast +template <class ToDuration, class Rep, class Period> + ToDuration duration_cast(const duration<Rep, Period>& d); + +// time_point arithmetic +template <class Clock, class Duration1, class Rep2, class Period2> + 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> + 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> + 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> + 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> + bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); +template <class Clock, class Duration1, class Duration2> + bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); +template <class Clock, class Duration1, class Duration2> + bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); +template <class Clock, class Duration1, class Duration2> + bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); +template <class Clock, class Duration1, class Duration2> + bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); +template <class Clock, class Duration1, class Duration2> + bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); + +// time_point_cast + +template <class ToDuration, class Clock, class Duration> + time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t); + +// Clocks + +class system_clock +{ +public: + typedef microseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point<system_clock> time_point; + static const bool is_steady = false; + + static time_point now() noexcept; + static time_t to_time_t (const time_point& __t) noexcept; + static time_point from_time_t(time_t __t) noexcept; +}; + +class steady_clock +{ +public: + typedef nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point<steady_clock, duration> time_point; + static const bool is_steady = true; + + static time_point now() noexcept; +}; + +typedef steady_clock high_resolution_clock; + +} // chrono + +} // std +*/ + +#include <__config> +#include <ctime> +#include <type_traits> +#include <ratio> +#include <limits> + +#include <__undef_min_max> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +namespace chrono +{ + +template <class _Rep, class _Period = ratio<1> > class _LIBCPP_VISIBLE duration; + +template <class _Tp> +struct __is_duration : false_type {}; + +template <class _Rep, class _Period> +struct __is_duration<duration<_Rep, _Period> > : true_type {}; + +template <class _Rep, class _Period> +struct __is_duration<const duration<_Rep, _Period> > : true_type {}; + +template <class _Rep, class _Period> +struct __is_duration<volatile duration<_Rep, _Period> > : true_type {}; + +template <class _Rep, class _Period> +struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {}; + +} // chrono + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +struct _LIBCPP_VISIBLE common_type<chrono::duration<_Rep1, _Period1>, + chrono::duration<_Rep2, _Period2> > +{ + typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, + typename __ratio_gcd<_Period1, _Period2>::type> type; +}; + +namespace chrono { + +// duration_cast + +template <class _FromDuration, class _ToDuration, + class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type, + bool = _Period::num == 1, + bool = _Period::den == 1> +struct __duration_cast; + +template <class _FromDuration, class _ToDuration, class _Period> +struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true> +{ + _LIBCPP_INLINE_VISIBILITY + _ToDuration operator()(const _FromDuration& __fd) const + { + return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count())); + } +}; + +template <class _FromDuration, class _ToDuration, class _Period> +struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false> +{ + _LIBCPP_INLINE_VISIBILITY + _ToDuration operator()(const _FromDuration& __fd) const + { + typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; + return _ToDuration(static_cast<typename _ToDuration::rep>( + static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den))); + } +}; + +template <class _FromDuration, class _ToDuration, class _Period> +struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true> +{ + _LIBCPP_INLINE_VISIBILITY + _ToDuration operator()(const _FromDuration& __fd) const + { + typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; + return _ToDuration(static_cast<typename _ToDuration::rep>( + static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num))); + } +}; + +template <class _FromDuration, class _ToDuration, class _Period> +struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false> +{ + _LIBCPP_INLINE_VISIBILITY + _ToDuration operator()(const _FromDuration& __fd) const + { + typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; + return _ToDuration(static_cast<typename _ToDuration::rep>( + static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num) + / static_cast<_Ct>(_Period::den))); + } +}; + +template <class _ToDuration, class _Rep, class _Period> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + __is_duration<_ToDuration>::value, + _ToDuration +>::type +duration_cast(const duration<_Rep, _Period>& __fd) +{ + return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd); +} + +template <class _Rep> +struct _LIBCPP_VISIBLE treat_as_floating_point : is_floating_point<_Rep> {}; + +template <class _Rep> +struct _LIBCPP_VISIBLE duration_values +{ +public: + _LIBCPP_INLINE_VISIBILITY static _Rep zero() {return _Rep(0);} + _LIBCPP_INLINE_VISIBILITY static _Rep max() {return numeric_limits<_Rep>::max();} + _LIBCPP_INLINE_VISIBILITY static _Rep min() {return numeric_limits<_Rep>::lowest();} +}; + +// duration + +template <class _Rep, class _Period> +class _LIBCPP_VISIBLE duration +{ + static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration"); + static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio"); + static_assert(_Period::num > 0, "duration period must be positive"); +public: + typedef _Rep rep; + typedef _Period period; +private: + rep __rep_; +public: + + _LIBCPP_INLINE_VISIBILITY duration() {} // = default; + template <class _Rep2> + _LIBCPP_INLINE_VISIBILITY + explicit duration(const _Rep2& __r, + typename enable_if + < + is_convertible<_Rep2, rep>::value && + (treat_as_floating_point<rep>::value || + !treat_as_floating_point<_Rep2>::value) + >::type* = 0) + : __rep_(__r) {} + + // conversions + template <class _Rep2, class _Period2> + _LIBCPP_INLINE_VISIBILITY + duration(const duration<_Rep2, _Period2>& __d, + typename enable_if + < + treat_as_floating_point<rep>::value || + (ratio_divide<_Period2, period>::type::den == 1 && + !treat_as_floating_point<_Rep2>::value) + >::type* = 0) + : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {} + + // observer + + _LIBCPP_INLINE_VISIBILITY rep count() const {return __rep_;} + + // arithmetic + + _LIBCPP_INLINE_VISIBILITY duration operator+() const {return *this;} + _LIBCPP_INLINE_VISIBILITY duration operator-() const {return duration(-__rep_);} + _LIBCPP_INLINE_VISIBILITY duration& operator++() {++__rep_; return *this;} + _LIBCPP_INLINE_VISIBILITY duration operator++(int) {return duration(__rep_++);} + _LIBCPP_INLINE_VISIBILITY duration& operator--() {--__rep_; return *this;} + _LIBCPP_INLINE_VISIBILITY duration operator--(int) {return duration(__rep_--);} + + _LIBCPP_INLINE_VISIBILITY duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;} + _LIBCPP_INLINE_VISIBILITY duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;} + + _LIBCPP_INLINE_VISIBILITY duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;} + _LIBCPP_INLINE_VISIBILITY duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;} + _LIBCPP_INLINE_VISIBILITY duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;} + _LIBCPP_INLINE_VISIBILITY duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;} + + // special values + + _LIBCPP_INLINE_VISIBILITY static duration zero() {return duration(duration_values<rep>::zero());} + _LIBCPP_INLINE_VISIBILITY static duration min() {return duration(duration_values<rep>::min());} + _LIBCPP_INLINE_VISIBILITY static duration max() {return duration(duration_values<rep>::max());} +}; + +typedef duration<long long, nano> nanoseconds; +typedef duration<long long, micro> microseconds; +typedef duration<long long, milli> milliseconds; +typedef duration<long long > seconds; +typedef duration< long, ratio< 60> > minutes; +typedef duration< long, ratio<3600> > hours; + +// Duration == + +template <class _LhsDuration, class _RhsDuration> +struct __duration_eq +{ + _LIBCPP_INLINE_VISIBILITY + bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) + { + typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; + return _Ct(__lhs).count() == _Ct(__rhs).count(); + } +}; + +template <class _LhsDuration> +struct __duration_eq<_LhsDuration, _LhsDuration> +{ + _LIBCPP_INLINE_VISIBILITY + bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) + {return __lhs.count() == __rhs.count();} +}; + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); +} + +// Duration != + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + return !(__lhs == __rhs); +} + +// Duration < + +template <class _LhsDuration, class _RhsDuration> +struct __duration_lt +{ + _LIBCPP_INLINE_VISIBILITY + bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) + { + typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; + return _Ct(__lhs).count() < _Ct(__rhs).count(); + } +}; + +template <class _LhsDuration> +struct __duration_lt<_LhsDuration, _LhsDuration> +{ + _LIBCPP_INLINE_VISIBILITY + bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) + {return __lhs.count() < __rhs.count();} +}; + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); +} + +// Duration > + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + return __rhs < __lhs; +} + +// Duration <= + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + return !(__rhs < __lhs); +} + +// Duration >= + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +bool +operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + return !(__lhs < __rhs); +} + +// Duration + + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type +operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs; + __r += __rhs; + return __r; +} + +// Duration - + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type +operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs; + __r -= __rhs; + return __r; +} + +// Duration * + +template <class _Rep1, class _Period, class _Rep2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, + duration<typename common_type<_Rep1, _Rep2>::type, _Period> +>::type +operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) +{ + typedef typename common_type<_Rep1, _Rep2>::type _Cr; + duration<_Cr, _Period> __r = __d; + __r *= static_cast<_Cr>(__s); + return __r; +} + +template <class _Rep1, class _Period, class _Rep2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, + duration<typename common_type<_Rep1, _Rep2>::type, _Period> +>::type +operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) +{ + return __d * __s; +} + +// Duration / + +template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value> +struct __duration_divide_result +{ +}; + +template <class _Duration, class _Rep2, + bool = is_convertible<_Rep2, + typename common_type<typename _Duration::rep, _Rep2>::type>::value> +struct __duration_divide_imp +{ +}; + +template <class _Rep1, class _Period, class _Rep2> +struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true> +{ + typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type; +}; + +template <class _Rep1, class _Period, class _Rep2> +struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false> + : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2> +{ +}; + +template <class _Rep1, class _Period, class _Rep2> +inline _LIBCPP_INLINE_VISIBILITY +typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type +operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) +{ + typedef typename common_type<_Rep1, _Rep2>::type _Cr; + duration<_Cr, _Period> __r = __d; + __r /= static_cast<_Cr>(__s); + return __r; +} + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +typename common_type<_Rep1, _Rep2>::type +operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct; + return _Ct(__lhs).count() / _Ct(__rhs).count(); +} + +// Duration % + +template <class _Rep1, class _Period, class _Rep2> +inline _LIBCPP_INLINE_VISIBILITY +typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type +operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) +{ + typedef typename common_type<_Rep1, _Rep2>::type _Cr; + duration<_Cr, _Period> __r = __d; + __r %= static_cast<_Cr>(__s); + return __r; +} + +template <class _Rep1, class _Period1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type +operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type __r = __lhs; + __r %= __rhs; + return __r; +} + +////////////////////////////////////////////////////////// +///////////////////// time_point ///////////////////////// +////////////////////////////////////////////////////////// + +template <class _Clock, class _Duration = typename _Clock::duration> +class _LIBCPP_VISIBLE time_point +{ + static_assert(__is_duration<_Duration>::value, + "Second template parameter of time_point must be a std::chrono::duration"); +public: + typedef _Clock clock; + typedef _Duration duration; + typedef typename duration::rep rep; + typedef typename duration::period period; +private: + duration __d_; + +public: + _LIBCPP_INLINE_VISIBILITY time_point() : __d_(duration::zero()) {} + _LIBCPP_INLINE_VISIBILITY explicit time_point(const duration& __d) : __d_(__d) {} + + // conversions + template <class _Duration2> + _LIBCPP_INLINE_VISIBILITY + time_point(const time_point<clock, _Duration2>& t, + typename enable_if + < + is_convertible<_Duration2, duration>::value + >::type* = 0) + : __d_(t.time_since_epoch()) {} + + // observer + + _LIBCPP_INLINE_VISIBILITY duration time_since_epoch() const {return __d_;} + + // arithmetic + + _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d;} + _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d;} + + // special values + + _LIBCPP_INLINE_VISIBILITY static time_point min() {return time_point(duration::min());} + _LIBCPP_INLINE_VISIBILITY static time_point max() {return time_point(duration::max());} +}; + +} // chrono + +template <class _Clock, class _Duration1, class _Duration2> +struct _LIBCPP_VISIBLE 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 { + +template <class _ToDuration, class _Clock, class _Duration> +inline _LIBCPP_INLINE_VISIBILITY +time_point<_Clock, _ToDuration> +time_point_cast(const time_point<_Clock, _Duration>& __t) +{ + return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); +} + +// time_point == + +template <class _Clock, class _Duration1, class _Duration2> +inline _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +bool +operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) +{ + return !(__lhs < __rhs); +} + +// time_point operator+(time_point x, duration y); + +template <class _Clock, class _Duration1, class _Rep2, class _Period2> +inline _LIBCPP_INLINE_VISIBILITY +time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> +operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) +{ + typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr; + _Tr __r(__lhs.time_since_epoch()); + __r += __rhs; + return __r; +} + +// time_point operator+(duration x, time_point y); + +template <class _Rep1, class _Period1, class _Clock, class _Duration2> +inline _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +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 _LIBCPP_INLINE_VISIBILITY +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(); +} + +////////////////////////////////////////////////////////// +/////////////////////// clocks /////////////////////////// +////////////////////////////////////////////////////////// + +class _LIBCPP_VISIBLE system_clock +{ +public: + typedef microseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point<system_clock> time_point; + static const bool is_steady = false; + + static time_point now() _NOEXCEPT; + static time_t to_time_t (const time_point& __t) _NOEXCEPT; + static time_point from_time_t(time_t __t) _NOEXCEPT; +}; + +class _LIBCPP_VISIBLE steady_clock +{ +public: + typedef nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point<steady_clock, duration> time_point; + static const bool is_steady = true; + + static time_point now() _NOEXCEPT; +}; + +typedef steady_clock high_resolution_clock; + +} // chrono + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_CHRONO |
