2 //===---------------------------- chrono ----------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef _LIBCPP_CHRONO
12 #define _LIBCPP_CHRONO
22 template <class ToDuration, class Rep, class Period>
25 duration_cast(const duration<Rep, Period>& fd);
27 template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
29 template <class Rep> constexpr bool treat_as_floating_point_v
30 = treat_as_floating_point<Rep>::value; // C++17
33 struct duration_values
36 static constexpr Rep zero();
37 static constexpr Rep max();
38 static constexpr Rep min();
43 template <class Rep, class Period = ratio<1>>
46 static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
47 static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
48 static_assert(Period::num > 0, "duration period must be positive");
51 typedef Period period;
53 constexpr duration() = default;
55 constexpr explicit duration(const Rep2& r,
58 is_convertible<Rep2, rep>::value &&
59 (treat_as_floating_point<rep>::value ||
60 !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
64 template <class Rep2, class Period2>
65 constexpr duration(const duration<Rep2, Period2>& d,
68 treat_as_floating_point<rep>::value ||
69 ratio_divide<Period2, period>::type::den == 1
74 constexpr rep count() const;
78 constexpr duration operator+() const;
79 constexpr duration operator-() const;
80 duration& operator++();
81 duration operator++(int);
82 duration& operator--();
83 duration operator--(int);
85 duration& operator+=(const duration& d);
86 duration& operator-=(const duration& d);
88 duration& operator*=(const rep& rhs);
89 duration& operator/=(const rep& rhs);
93 static constexpr duration zero();
94 static constexpr duration min();
95 static constexpr duration max();
98 typedef duration<long long, nano> nanoseconds;
99 typedef duration<long long, micro> microseconds;
100 typedef duration<long long, milli> milliseconds;
101 typedef duration<long long > seconds;
102 typedef duration< long, ratio< 60> > minutes;
103 typedef duration< long, ratio<3600> > hours;
105 template <class Clock, class Duration = typename Clock::duration>
110 typedef Duration duration;
111 typedef typename duration::rep rep;
112 typedef typename duration::period period;
114 duration d_; // exposition only
117 time_point(); // has value "epoch" // constexpr in C++14
118 explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14
121 template <class Duration2>
122 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14
126 duration time_since_epoch() const; // constexpr in C++14
130 time_point& operator+=(const duration& d);
131 time_point& operator-=(const duration& d);
135 static constexpr time_point min();
136 static constexpr time_point max();
141 // common_type traits
142 template <class Rep1, class Period1, class Rep2, class Period2>
143 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
145 template <class Clock, class Duration1, class Duration2>
146 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
150 // duration arithmetic
151 template <class Rep1, class Period1, class Rep2, class Period2>
153 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
154 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
155 template <class Rep1, class Period1, class Rep2, class Period2>
157 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
158 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
159 template <class Rep1, class Period, class Rep2>
161 duration<typename common_type<Rep1, Rep2>::type, Period>
162 operator*(const duration<Rep1, Period>& d, const Rep2& s);
163 template <class Rep1, class Period, class Rep2>
165 duration<typename common_type<Rep1, Rep2>::type, Period>
166 operator*(const Rep1& s, const duration<Rep2, Period>& d);
167 template <class Rep1, class Period, class Rep2>
169 duration<typename common_type<Rep1, Rep2>::type, Period>
170 operator/(const duration<Rep1, Period>& d, const Rep2& s);
171 template <class Rep1, class Period1, class Rep2, class Period2>
173 typename common_type<Rep1, Rep2>::type
174 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
176 // duration comparisons
177 template <class Rep1, class Period1, class Rep2, class Period2>
179 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
180 template <class Rep1, class Period1, class Rep2, class Period2>
182 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
183 template <class Rep1, class Period1, class Rep2, class Period2>
185 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
186 template <class Rep1, class Period1, class Rep2, class Period2>
188 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
189 template <class Rep1, class Period1, class Rep2, class Period2>
191 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
192 template <class Rep1, class Period1, class Rep2, class Period2>
194 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
197 template <class ToDuration, class Rep, class Period>
198 ToDuration duration_cast(const duration<Rep, Period>& d);
200 template <class ToDuration, class Rep, class Period>
201 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17
202 template <class ToDuration, class Rep, class Period>
203 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17
204 template <class ToDuration, class Rep, class Period>
205 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17
207 // time_point arithmetic (all constexpr in C++14)
208 template <class Clock, class Duration1, class Rep2, class Period2>
209 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
210 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
211 template <class Rep1, class Period1, class Clock, class Duration2>
212 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
213 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
214 template <class Clock, class Duration1, class Rep2, class Period2>
215 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
216 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
217 template <class Clock, class Duration1, class Duration2>
218 typename common_type<Duration1, Duration2>::type
219 operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
221 // time_point comparisons (all constexpr in C++14)
222 template <class Clock, class Duration1, class Duration2>
223 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
224 template <class Clock, class Duration1, class Duration2>
225 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
226 template <class Clock, class Duration1, class Duration2>
227 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
228 template <class Clock, class Duration1, class Duration2>
229 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
230 template <class Clock, class Duration1, class Duration2>
231 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
232 template <class Clock, class Duration1, class Duration2>
233 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
235 // time_point_cast (constexpr in C++14)
237 template <class ToDuration, class Clock, class Duration>
238 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
240 template <class ToDuration, class Clock, class Duration>
241 constexpr time_point<Clock, ToDuration>
242 floor(const time_point<Clock, Duration>& tp); // C++17
244 template <class ToDuration, class Clock, class Duration>
245 constexpr time_point<Clock, ToDuration>
246 ceil(const time_point<Clock, Duration>& tp); // C++17
248 template <class ToDuration, class Clock, class Duration>
249 constexpr time_point<Clock, ToDuration>
250 round(const time_point<Clock, Duration>& tp); // C++17
252 template <class Rep, class Period>
253 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17
259 typedef microseconds duration;
260 typedef duration::rep rep;
261 typedef duration::period period;
262 typedef chrono::time_point<system_clock> time_point;
263 static const bool is_steady = false; // constexpr in C++14
265 static time_point now() noexcept;
266 static time_t to_time_t (const time_point& __t) noexcept;
267 static time_point from_time_t(time_t __t) noexcept;
273 typedef nanoseconds duration;
274 typedef duration::rep rep;
275 typedef duration::period period;
276 typedef chrono::time_point<steady_clock, duration> time_point;
277 static const bool is_steady = true; // constexpr in C++14
279 static time_point now() noexcept;
282 typedef steady_clock high_resolution_clock;
286 constexpr chrono::hours operator "" h(unsigned long long); // C++14
287 constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long double); // C++14
288 constexpr chrono::minutes operator "" min(unsigned long long); // C++14
289 constexpr chrono::duration<unspecified , ratio<60,1>> operator "" min(long double); // C++14
290 constexpr chrono::seconds operator "" s(unsigned long long); // C++14
291 constexpr chrono::duration<unspecified > operator "" s(long double); // C++14
292 constexpr chrono::milliseconds operator "" ms(unsigned long long); // C++14
293 constexpr chrono::duration<unspecified , milli> operator "" ms(long double); // C++14
294 constexpr chrono::microseconds operator "" us(unsigned long long); // C++14
295 constexpr chrono::duration<unspecified , micro> operator "" us(long double); // C++14
296 constexpr chrono::nanoseconds operator "" ns(unsigned long long); // C++14
297 constexpr chrono::duration<unspecified , nano> operator "" ns(long double); // C++14
304 #include <type_traits>
308 #include <__undef_min_max>
310 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
311 #pragma GCC system_header
314 _LIBCPP_BEGIN_NAMESPACE_STD
319 template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TYPE_VIS_ONLY duration;
322 struct __is_duration : false_type {};
324 template <class _Rep, class _Period>
325 struct __is_duration<duration<_Rep, _Period> > : true_type {};
327 template <class _Rep, class _Period>
328 struct __is_duration<const duration<_Rep, _Period> > : true_type {};
330 template <class _Rep, class _Period>
331 struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
333 template <class _Rep, class _Period>
334 struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
338 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
339 struct _LIBCPP_TYPE_VIS_ONLY common_type<chrono::duration<_Rep1, _Period1>,
340 chrono::duration<_Rep2, _Period2> >
342 typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
343 typename __ratio_gcd<_Period1, _Period2>::type> type;
350 template <class _FromDuration, class _ToDuration,
351 class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
352 bool = _Period::num == 1,
353 bool = _Period::den == 1>
354 struct __duration_cast;
356 template <class _FromDuration, class _ToDuration, class _Period>
357 struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
359 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
360 _ToDuration operator()(const _FromDuration& __fd) const
362 return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
366 template <class _FromDuration, class _ToDuration, class _Period>
367 struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
369 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
370 _ToDuration operator()(const _FromDuration& __fd) const
372 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
373 return _ToDuration(static_cast<typename _ToDuration::rep>(
374 static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
378 template <class _FromDuration, class _ToDuration, class _Period>
379 struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
381 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
382 _ToDuration operator()(const _FromDuration& __fd) const
384 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
385 return _ToDuration(static_cast<typename _ToDuration::rep>(
386 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
390 template <class _FromDuration, class _ToDuration, class _Period>
391 struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
393 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
394 _ToDuration operator()(const _FromDuration& __fd) const
396 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
397 return _ToDuration(static_cast<typename _ToDuration::rep>(
398 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
399 / static_cast<_Ct>(_Period::den)));
403 template <class _ToDuration, class _Rep, class _Period>
404 inline _LIBCPP_INLINE_VISIBILITY
408 __is_duration<_ToDuration>::value,
411 duration_cast(const duration<_Rep, _Period>& __fd)
413 return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
416 template <class _Rep>
417 struct _LIBCPP_TYPE_VIS_ONLY treat_as_floating_point : is_floating_point<_Rep> {};
419 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
420 template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
421 = treat_as_floating_point<_Rep>::value;
424 template <class _Rep>
425 struct _LIBCPP_TYPE_VIS_ONLY duration_values
428 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
429 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();}
430 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();}
433 #if _LIBCPP_STD_VER > 14
434 template <class _ToDuration, class _Rep, class _Period>
435 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
438 __is_duration<_ToDuration>::value,
441 floor(const duration<_Rep, _Period>& __d)
443 _ToDuration __t = duration_cast<_ToDuration>(__d);
445 __t = __t - _ToDuration{1};
449 template <class _ToDuration, class _Rep, class _Period>
450 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
453 __is_duration<_ToDuration>::value,
456 ceil(const duration<_Rep, _Period>& __d)
458 _ToDuration __t = duration_cast<_ToDuration>(__d);
460 __t = __t + _ToDuration{1};
464 template <class _ToDuration, class _Rep, class _Period>
465 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
468 __is_duration<_ToDuration>::value,
471 round(const duration<_Rep, _Period>& __d)
473 _ToDuration __lower = floor<_ToDuration>(__d);
474 _ToDuration __upper = __lower + _ToDuration{1};
475 auto __lowerDiff = __d - __lower;
476 auto __upperDiff = __upper - __d;
477 if (__lowerDiff < __upperDiff)
479 if (__lowerDiff > __upperDiff)
481 return __lower.count() & 1 ? __upper : __lower;
487 template <class _Rep, class _Period>
488 class _LIBCPP_TYPE_VIS_ONLY duration
490 static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
491 static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
492 static_assert(_Period::num > 0, "duration period must be positive");
494 template <class _R1, class _R2>
498 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
499 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
500 static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
501 static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
502 static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
503 static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
504 static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
506 template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
507 struct __mul // __overflow == false
509 static const intmax_t value = _Xp * _Yp;
512 template <intmax_t _Xp, intmax_t _Yp>
513 struct __mul<_Xp, _Yp, true>
515 static const intmax_t value = 1;
519 static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
520 typedef ratio<__mul<__n1, __d2, !value>::value,
521 __mul<__n2, __d1, !value>::value> type;
526 typedef _Period period;
531 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
532 #ifndef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
533 duration() = default;
538 template <class _Rep2>
539 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
540 explicit duration(const _Rep2& __r,
543 is_convertible<_Rep2, rep>::value &&
544 (treat_as_floating_point<rep>::value ||
545 !treat_as_floating_point<_Rep2>::value)
550 template <class _Rep2, class _Period2>
551 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
552 duration(const duration<_Rep2, _Period2>& __d,
555 __no_overflow<_Period2, period>::value && (
556 treat_as_floating_point<rep>::value ||
557 (__no_overflow<_Period2, period>::type::den == 1 &&
558 !treat_as_floating_point<_Rep2>::value))
560 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
564 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
568 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator+() const {return *this;}
569 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator-() const {return duration(-__rep_);}
570 _LIBCPP_INLINE_VISIBILITY duration& operator++() {++__rep_; return *this;}
571 _LIBCPP_INLINE_VISIBILITY duration operator++(int) {return duration(__rep_++);}
572 _LIBCPP_INLINE_VISIBILITY duration& operator--() {--__rep_; return *this;}
573 _LIBCPP_INLINE_VISIBILITY duration operator--(int) {return duration(__rep_--);}
575 _LIBCPP_INLINE_VISIBILITY duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
576 _LIBCPP_INLINE_VISIBILITY duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
578 _LIBCPP_INLINE_VISIBILITY duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
579 _LIBCPP_INLINE_VISIBILITY duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
580 _LIBCPP_INLINE_VISIBILITY duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
581 _LIBCPP_INLINE_VISIBILITY duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
585 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
586 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());}
587 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());}
590 typedef duration<long long, nano> nanoseconds;
591 typedef duration<long long, micro> microseconds;
592 typedef duration<long long, milli> milliseconds;
593 typedef duration<long long > seconds;
594 typedef duration< long, ratio< 60> > minutes;
595 typedef duration< long, ratio<3600> > hours;
599 template <class _LhsDuration, class _RhsDuration>
602 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
603 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
605 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
606 return _Ct(__lhs).count() == _Ct(__rhs).count();
610 template <class _LhsDuration>
611 struct __duration_eq<_LhsDuration, _LhsDuration>
613 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
614 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
615 {return __lhs.count() == __rhs.count();}
618 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
619 inline _LIBCPP_INLINE_VISIBILITY
622 operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
624 return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
629 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
630 inline _LIBCPP_INLINE_VISIBILITY
633 operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
635 return !(__lhs == __rhs);
640 template <class _LhsDuration, class _RhsDuration>
643 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
644 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
646 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
647 return _Ct(__lhs).count() < _Ct(__rhs).count();
651 template <class _LhsDuration>
652 struct __duration_lt<_LhsDuration, _LhsDuration>
654 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
655 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
656 {return __lhs.count() < __rhs.count();}
659 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
660 inline _LIBCPP_INLINE_VISIBILITY
663 operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
665 return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
670 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
671 inline _LIBCPP_INLINE_VISIBILITY
674 operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
676 return __rhs < __lhs;
681 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
682 inline _LIBCPP_INLINE_VISIBILITY
685 operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
687 return !(__rhs < __lhs);
692 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
693 inline _LIBCPP_INLINE_VISIBILITY
696 operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
698 return !(__lhs < __rhs);
703 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
704 inline _LIBCPP_INLINE_VISIBILITY
706 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
707 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
709 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
710 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
715 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
716 inline _LIBCPP_INLINE_VISIBILITY
718 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
719 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
721 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
722 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
727 template <class _Rep1, class _Period, class _Rep2>
728 inline _LIBCPP_INLINE_VISIBILITY
732 is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
733 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
735 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
737 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
738 typedef duration<_Cr, _Period> _Cd;
739 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
742 template <class _Rep1, class _Period, class _Rep2>
743 inline _LIBCPP_INLINE_VISIBILITY
747 is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
748 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
750 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
757 template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
758 struct __duration_divide_result
762 template <class _Duration, class _Rep2,
763 bool = is_convertible<_Rep2,
764 typename common_type<typename _Duration::rep, _Rep2>::type>::value>
765 struct __duration_divide_imp
769 template <class _Rep1, class _Period, class _Rep2>
770 struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
772 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
775 template <class _Rep1, class _Period, class _Rep2>
776 struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
777 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
781 template <class _Rep1, class _Period, class _Rep2>
782 inline _LIBCPP_INLINE_VISIBILITY
784 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
785 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
787 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
788 typedef duration<_Cr, _Period> _Cd;
789 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
792 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
793 inline _LIBCPP_INLINE_VISIBILITY
795 typename common_type<_Rep1, _Rep2>::type
796 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
798 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
799 return _Ct(__lhs).count() / _Ct(__rhs).count();
804 template <class _Rep1, class _Period, class _Rep2>
805 inline _LIBCPP_INLINE_VISIBILITY
807 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
808 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
810 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
811 typedef duration<_Cr, _Period> _Cd;
812 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
815 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
816 inline _LIBCPP_INLINE_VISIBILITY
818 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
819 operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
821 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
822 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
823 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
826 //////////////////////////////////////////////////////////
827 ///////////////////// time_point /////////////////////////
828 //////////////////////////////////////////////////////////
830 template <class _Clock, class _Duration = typename _Clock::duration>
831 class _LIBCPP_TYPE_VIS_ONLY time_point
833 static_assert(__is_duration<_Duration>::value,
834 "Second template parameter of time_point must be a std::chrono::duration");
836 typedef _Clock clock;
837 typedef _Duration duration;
838 typedef typename duration::rep rep;
839 typedef typename duration::period period;
844 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
845 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}
848 template <class _Duration2>
849 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
850 time_point(const time_point<clock, _Duration2>& t,
853 is_convertible<_Duration2, duration>::value
855 : __d_(t.time_since_epoch()) {}
859 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}
863 _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
864 _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
868 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
869 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
874 template <class _Clock, class _Duration1, class _Duration2>
875 struct _LIBCPP_TYPE_VIS_ONLY common_type<chrono::time_point<_Clock, _Duration1>,
876 chrono::time_point<_Clock, _Duration2> >
878 typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
883 template <class _ToDuration, class _Clock, class _Duration>
884 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
885 time_point<_Clock, _ToDuration>
886 time_point_cast(const time_point<_Clock, _Duration>& __t)
888 return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
891 #if _LIBCPP_STD_VER > 14
892 template <class _ToDuration, class _Clock, class _Duration>
893 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
896 __is_duration<_ToDuration>::value,
897 time_point<_Clock, _ToDuration>
899 floor(const time_point<_Clock, _Duration>& __t)
901 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
904 template <class _ToDuration, class _Clock, class _Duration>
905 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
908 __is_duration<_ToDuration>::value,
909 time_point<_Clock, _ToDuration>
911 ceil(const time_point<_Clock, _Duration>& __t)
913 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
916 template <class _ToDuration, class _Clock, class _Duration>
917 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
920 __is_duration<_ToDuration>::value,
921 time_point<_Clock, _ToDuration>
923 round(const time_point<_Clock, _Duration>& __t)
925 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
928 template <class _Rep, class _Period>
929 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
932 numeric_limits<_Rep>::is_signed,
933 duration<_Rep, _Period>
935 abs(duration<_Rep, _Period> __d)
937 return __d >= __d.zero() ? __d : -__d;
943 template <class _Clock, class _Duration1, class _Duration2>
944 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
946 operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
948 return __lhs.time_since_epoch() == __rhs.time_since_epoch();
953 template <class _Clock, class _Duration1, class _Duration2>
954 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
956 operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
958 return !(__lhs == __rhs);
963 template <class _Clock, class _Duration1, class _Duration2>
964 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
966 operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
968 return __lhs.time_since_epoch() < __rhs.time_since_epoch();
973 template <class _Clock, class _Duration1, class _Duration2>
974 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
976 operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
978 return __rhs < __lhs;
983 template <class _Clock, class _Duration1, class _Duration2>
984 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
986 operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
988 return !(__rhs < __lhs);
993 template <class _Clock, class _Duration1, class _Duration2>
994 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
996 operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
998 return !(__lhs < __rhs);
1001 // time_point operator+(time_point x, duration y);
1003 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1004 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1005 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1006 operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1008 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
1009 return _Tr (__lhs.time_since_epoch() + __rhs);
1012 // time_point operator+(duration x, time_point y);
1014 template <class _Rep1, class _Period1, class _Clock, class _Duration2>
1015 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1016 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
1017 operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1019 return __rhs + __lhs;
1022 // time_point operator-(time_point x, duration y);
1024 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1025 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1026 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1027 operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1029 return __lhs + (-__rhs);
1032 // duration operator-(time_point x, time_point y);
1034 template <class _Clock, class _Duration1, class _Duration2>
1035 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1036 typename common_type<_Duration1, _Duration2>::type
1037 operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1039 return __lhs.time_since_epoch() - __rhs.time_since_epoch();
1042 //////////////////////////////////////////////////////////
1043 /////////////////////// clocks ///////////////////////////
1044 //////////////////////////////////////////////////////////
1046 class _LIBCPP_TYPE_VIS system_clock
1049 typedef microseconds duration;
1050 typedef duration::rep rep;
1051 typedef duration::period period;
1052 typedef chrono::time_point<system_clock> time_point;
1053 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
1055 static time_point now() _NOEXCEPT;
1056 static time_t to_time_t (const time_point& __t) _NOEXCEPT;
1057 static time_point from_time_t(time_t __t) _NOEXCEPT;
1060 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
1061 class _LIBCPP_TYPE_VIS steady_clock
1064 typedef nanoseconds duration;
1065 typedef duration::rep rep;
1066 typedef duration::period period;
1067 typedef chrono::time_point<steady_clock, duration> time_point;
1068 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;
1070 static time_point now() _NOEXCEPT;
1073 typedef steady_clock high_resolution_clock;
1075 typedef system_clock high_resolution_clock;
1080 #if _LIBCPP_STD_VER > 11
1081 // Suffixes for duration literals [time.duration.literals]
1082 inline namespace literals
1084 inline namespace chrono_literals
1087 constexpr chrono::hours operator"" h(unsigned long long __h)
1089 return chrono::hours(static_cast<chrono::hours::rep>(__h));
1092 constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long double __h)
1094 return chrono::duration<long double, ratio<3600,1>>(__h);
1098 constexpr chrono::minutes operator"" min(unsigned long long __m)
1100 return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
1103 constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long double __m)
1105 return chrono::duration<long double, ratio<60,1>> (__m);
1109 constexpr chrono::seconds operator"" s(unsigned long long __s)
1111 return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
1114 constexpr chrono::duration<long double> operator"" s(long double __s)
1116 return chrono::duration<long double> (__s);
1120 constexpr chrono::milliseconds operator"" ms(unsigned long long __ms)
1122 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
1125 constexpr chrono::duration<long double, milli> operator"" ms(long double __ms)
1127 return chrono::duration<long double, milli>(__ms);
1131 constexpr chrono::microseconds operator"" us(unsigned long long __us)
1133 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
1136 constexpr chrono::duration<long double, micro> operator"" us(long double __us)
1138 return chrono::duration<long double, micro> (__us);
1142 constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns)
1144 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
1147 constexpr chrono::duration<long double, nano> operator"" ns(long double __ns)
1149 return chrono::duration<long double, nano> (__ns);
1154 namespace chrono { // hoist the literals into namespace std::chrono
1155 using namespace literals::chrono_literals;
1160 _LIBCPP_END_NAMESPACE_STD
1162 #endif // _LIBCPP_CHRONO