overby.me
this repo has no description
1// -*- C++ -*-
2//===---------------------------- chrono ----------------------------------===//
3//
4// The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_CHRONO
12#define _LIBCPP_CHRONO
13
14/*
15 chrono synopsis
16
17namespace std
18{
19namespace chrono
20{
21
22template <class ToDuration, class Rep, class Period>
23constexpr
24ToDuration
25duration_cast(const duration<Rep, Period>& fd);
26
27template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
28
29template <class Rep> constexpr bool treat_as_floating_point_v
30 = treat_as_floating_point<Rep>::value; // C++17
31
32template <class Rep>
33struct duration_values
34{
35public:
36 static constexpr Rep zero();
37 static constexpr Rep max();
38 static constexpr Rep min();
39};
40
41// duration
42
43template <class Rep, class Period = ratio<1>>
44class duration
45{
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");
49public:
50 typedef Rep rep;
51 typedef typename _Period::type period;
52
53 constexpr duration() = default;
54 template <class Rep2>
55 constexpr explicit duration(const Rep2& r,
56 typename enable_if
57 <
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)
61 >::type* = 0);
62
63 // conversions
64 template <class Rep2, class Period2>
65 constexpr duration(const duration<Rep2, Period2>& d,
66 typename enable_if
67 <
68 treat_as_floating_point<rep>::value ||
69 ratio_divide<Period2, period>::type::den == 1
70 >::type* = 0);
71
72 // observer
73
74 constexpr rep count() const;
75
76 // arithmetic
77
78 constexpr common_type<duration>::type operator+() const;
79 constexpr common_type<duration>::type operator-() const;
80 constexpr duration& operator++();
81 constexpr duration operator++(int);
82 constexpr duration& operator--();
83 constexpr duration operator--(int);
84
85 constexpr duration& operator+=(const duration& d);
86 constexpr duration& operator-=(const duration& d);
87
88 duration& operator*=(const rep& rhs);
89 duration& operator/=(const rep& rhs);
90
91 // special values
92
93 static constexpr duration zero();
94 static constexpr duration min();
95 static constexpr duration max();
96};
97
98typedef duration<long long, nano> nanoseconds;
99typedef duration<long long, micro> microseconds;
100typedef duration<long long, milli> milliseconds;
101typedef duration<long long > seconds;
102typedef duration< long, ratio< 60> > minutes;
103typedef duration< long, ratio<3600> > hours;
104
105template <class Clock, class Duration = typename Clock::duration>
106class time_point
107{
108public:
109 typedef Clock clock;
110 typedef Duration duration;
111 typedef typename duration::rep rep;
112 typedef typename duration::period period;
113private:
114 duration d_; // exposition only
115
116public:
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
119
120 // conversions
121 template <class Duration2>
122 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14
123
124 // observer
125
126 duration time_since_epoch() const; // constexpr in C++14
127
128 // arithmetic
129
130 time_point& operator+=(const duration& d);
131 time_point& operator-=(const duration& d);
132
133 // special values
134
135 static constexpr time_point min();
136 static constexpr time_point max();
137};
138
139} // chrono
140
141// common_type traits
142template <class Rep1, class Period1, class Rep2, class Period2>
143 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
144
145template <class Clock, class Duration1, class Duration2>
146 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
147
148namespace chrono {
149
150// duration arithmetic
151template <class Rep1, class Period1, class Rep2, class Period2>
152 constexpr
153 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
154 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
155template <class Rep1, class Period1, class Rep2, class Period2>
156 constexpr
157 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
158 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
159template <class Rep1, class Period, class Rep2>
160 constexpr
161 duration<typename common_type<Rep1, Rep2>::type, Period>
162 operator*(const duration<Rep1, Period>& d, const Rep2& s);
163template <class Rep1, class Period, class Rep2>
164 constexpr
165 duration<typename common_type<Rep1, Rep2>::type, Period>
166 operator*(const Rep1& s, const duration<Rep2, Period>& d);
167template <class Rep1, class Period, class Rep2>
168 constexpr
169 duration<typename common_type<Rep1, Rep2>::type, Period>
170 operator/(const duration<Rep1, Period>& d, const Rep2& s);
171template <class Rep1, class Period1, class Rep2, class Period2>
172 constexpr
173 typename common_type<Rep1, Rep2>::type
174 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
175
176// duration comparisons
177template <class Rep1, class Period1, class Rep2, class Period2>
178 constexpr
179 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
180template <class Rep1, class Period1, class Rep2, class Period2>
181 constexpr
182 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
183template <class Rep1, class Period1, class Rep2, class Period2>
184 constexpr
185 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
186template <class Rep1, class Period1, class Rep2, class Period2>
187 constexpr
188 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
189template <class Rep1, class Period1, class Rep2, class Period2>
190 constexpr
191 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
192template <class Rep1, class Period1, class Rep2, class Period2>
193 constexpr
194 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
195
196// duration_cast
197template <class ToDuration, class Rep, class Period>
198 ToDuration duration_cast(const duration<Rep, Period>& d);
199
200template <class ToDuration, class Rep, class Period>
201 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17
202template <class ToDuration, class Rep, class Period>
203 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17
204template <class ToDuration, class Rep, class Period>
205 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17
206
207// time_point arithmetic (all constexpr in C++14)
208template <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);
211template <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);
214template <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);
217template <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);
220
221// time_point comparisons (all constexpr in C++14)
222template <class Clock, class Duration1, class Duration2>
223 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
224template <class Clock, class Duration1, class Duration2>
225 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
226template <class Clock, class Duration1, class Duration2>
227 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
228template <class Clock, class Duration1, class Duration2>
229 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
230template <class Clock, class Duration1, class Duration2>
231 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
232template <class Clock, class Duration1, class Duration2>
233 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
234
235// time_point_cast (constexpr in C++14)
236
237template <class ToDuration, class Clock, class Duration>
238 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
239
240template <class ToDuration, class Clock, class Duration>
241 constexpr time_point<Clock, ToDuration>
242 floor(const time_point<Clock, Duration>& tp); // C++17
243
244template <class ToDuration, class Clock, class Duration>
245 constexpr time_point<Clock, ToDuration>
246 ceil(const time_point<Clock, Duration>& tp); // C++17
247
248template <class ToDuration, class Clock, class Duration>
249 constexpr time_point<Clock, ToDuration>
250 round(const time_point<Clock, Duration>& tp); // C++17
251
252template <class Rep, class Period>
253 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17
254// Clocks
255
256class system_clock
257{
258public:
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
264
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;
268};
269
270class steady_clock
271{
272public:
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
278
279 static time_point now() noexcept;
280};
281
282typedef steady_clock high_resolution_clock;
283
284} // chrono
285
286constexpr chrono::hours operator "" h(unsigned long long); // C++14
287constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long double); // C++14
288constexpr chrono::minutes operator "" min(unsigned long long); // C++14
289constexpr chrono::duration<unspecified , ratio<60,1>> operator "" min(long double); // C++14
290constexpr chrono::seconds operator "" s(unsigned long long); // C++14
291constexpr chrono::duration<unspecified > operator "" s(long double); // C++14
292constexpr chrono::milliseconds operator "" ms(unsigned long long); // C++14
293constexpr chrono::duration<unspecified , milli> operator "" ms(long double); // C++14
294constexpr chrono::microseconds operator "" us(unsigned long long); // C++14
295constexpr chrono::duration<unspecified , micro> operator "" us(long double); // C++14
296constexpr chrono::nanoseconds operator "" ns(unsigned long long); // C++14
297constexpr chrono::duration<unspecified , nano> operator "" ns(long double); // C++14
298
299} // std
300*/
301
302#include <__config>
303#include <ctime>
304#include <type_traits>
305#include <ratio>
306#include <limits>
307
308#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
309#pragma GCC system_header
310#endif
311
312_LIBCPP_PUSH_MACROS
313#include <__undef_macros>
314
315
316_LIBCPP_BEGIN_NAMESPACE_STD
317
318namespace chrono
319{
320
321template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
322
323template <class _Tp>
324struct __is_duration : false_type {};
325
326template <class _Rep, class _Period>
327struct __is_duration<duration<_Rep, _Period> > : true_type {};
328
329template <class _Rep, class _Period>
330struct __is_duration<const duration<_Rep, _Period> > : true_type {};
331
332template <class _Rep, class _Period>
333struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
334
335template <class _Rep, class _Period>
336struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
337
338} // chrono
339
340template <class _Rep1, class _Period1, class _Rep2, class _Period2>
341struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
342 chrono::duration<_Rep2, _Period2> >
343{
344 typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
345 typename __ratio_gcd<_Period1, _Period2>::type> type;
346};
347
348namespace chrono {
349
350// duration_cast
351
352template <class _FromDuration, class _ToDuration,
353 class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
354 bool = _Period::num == 1,
355 bool = _Period::den == 1>
356struct __duration_cast;
357
358template <class _FromDuration, class _ToDuration, class _Period>
359struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
360{
361 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
362 _ToDuration operator()(const _FromDuration& __fd) const
363 {
364 return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
365 }
366};
367
368template <class _FromDuration, class _ToDuration, class _Period>
369struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
370{
371 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
372 _ToDuration operator()(const _FromDuration& __fd) const
373 {
374 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
375 return _ToDuration(static_cast<typename _ToDuration::rep>(
376 static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
377 }
378};
379
380template <class _FromDuration, class _ToDuration, class _Period>
381struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
382{
383 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
384 _ToDuration operator()(const _FromDuration& __fd) const
385 {
386 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
387 return _ToDuration(static_cast<typename _ToDuration::rep>(
388 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
389 }
390};
391
392template <class _FromDuration, class _ToDuration, class _Period>
393struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
394{
395 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
396 _ToDuration operator()(const _FromDuration& __fd) const
397 {
398 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
399 return _ToDuration(static_cast<typename _ToDuration::rep>(
400 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
401 / static_cast<_Ct>(_Period::den)));
402 }
403};
404
405template <class _ToDuration, class _Rep, class _Period>
406inline _LIBCPP_INLINE_VISIBILITY
407_LIBCPP_CONSTEXPR
408typename enable_if
409<
410 __is_duration<_ToDuration>::value,
411 _ToDuration
412>::type
413duration_cast(const duration<_Rep, _Period>& __fd)
414{
415 return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
416}
417
418template <class _Rep>
419struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
420
421#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
422template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
423 = treat_as_floating_point<_Rep>::value;
424#endif
425
426template <class _Rep>
427struct _LIBCPP_TEMPLATE_VIS duration_values
428{
429public:
430 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
431 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();}
432 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();}
433};
434
435#if _LIBCPP_STD_VER > 14
436template <class _ToDuration, class _Rep, class _Period>
437inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
438typename enable_if
439<
440 __is_duration<_ToDuration>::value,
441 _ToDuration
442>::type
443floor(const duration<_Rep, _Period>& __d)
444{
445 _ToDuration __t = duration_cast<_ToDuration>(__d);
446 if (__t > __d)
447 __t = __t - _ToDuration{1};
448 return __t;
449}
450
451template <class _ToDuration, class _Rep, class _Period>
452inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
453typename enable_if
454<
455 __is_duration<_ToDuration>::value,
456 _ToDuration
457>::type
458ceil(const duration<_Rep, _Period>& __d)
459{
460 _ToDuration __t = duration_cast<_ToDuration>(__d);
461 if (__t < __d)
462 __t = __t + _ToDuration{1};
463 return __t;
464}
465
466template <class _ToDuration, class _Rep, class _Period>
467inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
468typename enable_if
469<
470 __is_duration<_ToDuration>::value,
471 _ToDuration
472>::type
473round(const duration<_Rep, _Period>& __d)
474{
475 _ToDuration __lower = floor<_ToDuration>(__d);
476 _ToDuration __upper = __lower + _ToDuration{1};
477 auto __lowerDiff = __d - __lower;
478 auto __upperDiff = __upper - __d;
479 if (__lowerDiff < __upperDiff)
480 return __lower;
481 if (__lowerDiff > __upperDiff)
482 return __upper;
483 return __lower.count() & 1 ? __upper : __lower;
484}
485#endif
486
487// duration
488
489template <class _Rep, class _Period>
490class _LIBCPP_TEMPLATE_VIS duration
491{
492 static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
493 static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
494 static_assert(_Period::num > 0, "duration period must be positive");
495
496 template <class _R1, class _R2>
497 struct __no_overflow
498 {
499 private:
500 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
501 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
502 static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
503 static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
504 static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
505 static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
506 static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
507
508 template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
509 struct __mul // __overflow == false
510 {
511 static const intmax_t value = _Xp * _Yp;
512 };
513
514 template <intmax_t _Xp, intmax_t _Yp>
515 struct __mul<_Xp, _Yp, true>
516 {
517 static const intmax_t value = 1;
518 };
519
520 public:
521 static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
522 typedef ratio<__mul<__n1, __d2, !value>::value,
523 __mul<__n2, __d1, !value>::value> type;
524 };
525
526public:
527 typedef _Rep rep;
528 typedef typename _Period::type period;
529private:
530 rep __rep_;
531public:
532
533 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
534#ifndef _LIBCPP_CXX03_LANG
535 duration() = default;
536#else
537 duration() {}
538#endif
539
540 template <class _Rep2>
541 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
542 explicit duration(const _Rep2& __r,
543 typename enable_if
544 <
545 is_convertible<_Rep2, rep>::value &&
546 (treat_as_floating_point<rep>::value ||
547 !treat_as_floating_point<_Rep2>::value)
548 >::type* = 0)
549 : __rep_(__r) {}
550
551 // conversions
552 template <class _Rep2, class _Period2>
553 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
554 duration(const duration<_Rep2, _Period2>& __d,
555 typename enable_if
556 <
557 __no_overflow<_Period2, period>::value && (
558 treat_as_floating_point<rep>::value ||
559 (__no_overflow<_Period2, period>::type::den == 1 &&
560 !treat_as_floating_point<_Rep2>::value))
561 >::type* = 0)
562 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
563
564 // observer
565
566 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
567
568 // arithmetic
569
570 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
571 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
572 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;}
573 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);}
574 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;}
575 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);}
576
577 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
578 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
579
580 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
581 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
582 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
583 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
584
585 // special values
586
587 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
588 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());}
589 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());}
590};
591
592typedef duration<long long, nano> nanoseconds;
593typedef duration<long long, micro> microseconds;
594typedef duration<long long, milli> milliseconds;
595typedef duration<long long > seconds;
596typedef duration< long, ratio< 60> > minutes;
597typedef duration< long, ratio<3600> > hours;
598
599// Duration ==
600
601template <class _LhsDuration, class _RhsDuration>
602struct __duration_eq
603{
604 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
605 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
606 {
607 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
608 return _Ct(__lhs).count() == _Ct(__rhs).count();
609 }
610};
611
612template <class _LhsDuration>
613struct __duration_eq<_LhsDuration, _LhsDuration>
614{
615 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
616 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
617 {return __lhs.count() == __rhs.count();}
618};
619
620template <class _Rep1, class _Period1, class _Rep2, class _Period2>
621inline _LIBCPP_INLINE_VISIBILITY
622_LIBCPP_CONSTEXPR
623bool
624operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
625{
626 return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
627}
628
629// Duration !=
630
631template <class _Rep1, class _Period1, class _Rep2, class _Period2>
632inline _LIBCPP_INLINE_VISIBILITY
633_LIBCPP_CONSTEXPR
634bool
635operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
636{
637 return !(__lhs == __rhs);
638}
639
640// Duration <
641
642template <class _LhsDuration, class _RhsDuration>
643struct __duration_lt
644{
645 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
646 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
647 {
648 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
649 return _Ct(__lhs).count() < _Ct(__rhs).count();
650 }
651};
652
653template <class _LhsDuration>
654struct __duration_lt<_LhsDuration, _LhsDuration>
655{
656 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
657 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
658 {return __lhs.count() < __rhs.count();}
659};
660
661template <class _Rep1, class _Period1, class _Rep2, class _Period2>
662inline _LIBCPP_INLINE_VISIBILITY
663_LIBCPP_CONSTEXPR
664bool
665operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
666{
667 return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
668}
669
670// Duration >
671
672template <class _Rep1, class _Period1, class _Rep2, class _Period2>
673inline _LIBCPP_INLINE_VISIBILITY
674_LIBCPP_CONSTEXPR
675bool
676operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
677{
678 return __rhs < __lhs;
679}
680
681// Duration <=
682
683template <class _Rep1, class _Period1, class _Rep2, class _Period2>
684inline _LIBCPP_INLINE_VISIBILITY
685_LIBCPP_CONSTEXPR
686bool
687operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
688{
689 return !(__rhs < __lhs);
690}
691
692// Duration >=
693
694template <class _Rep1, class _Period1, class _Rep2, class _Period2>
695inline _LIBCPP_INLINE_VISIBILITY
696_LIBCPP_CONSTEXPR
697bool
698operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
699{
700 return !(__lhs < __rhs);
701}
702
703// Duration +
704
705template <class _Rep1, class _Period1, class _Rep2, class _Period2>
706inline _LIBCPP_INLINE_VISIBILITY
707_LIBCPP_CONSTEXPR
708typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
709operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
710{
711 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
712 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
713}
714
715// Duration -
716
717template <class _Rep1, class _Period1, class _Rep2, class _Period2>
718inline _LIBCPP_INLINE_VISIBILITY
719_LIBCPP_CONSTEXPR
720typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
721operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
722{
723 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
724 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
725}
726
727// Duration *
728
729template <class _Rep1, class _Period, class _Rep2>
730inline _LIBCPP_INLINE_VISIBILITY
731_LIBCPP_CONSTEXPR
732typename enable_if
733<
734 is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
735 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
736>::type
737operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
738{
739 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
740 typedef duration<_Cr, _Period> _Cd;
741 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
742}
743
744template <class _Rep1, class _Period, class _Rep2>
745inline _LIBCPP_INLINE_VISIBILITY
746_LIBCPP_CONSTEXPR
747typename enable_if
748<
749 is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
750 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
751>::type
752operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
753{
754 return __d * __s;
755}
756
757// Duration /
758
759template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
760struct __duration_divide_result
761{
762};
763
764template <class _Duration, class _Rep2,
765 bool = is_convertible<_Rep2,
766 typename common_type<typename _Duration::rep, _Rep2>::type>::value>
767struct __duration_divide_imp
768{
769};
770
771template <class _Rep1, class _Period, class _Rep2>
772struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
773{
774 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
775};
776
777template <class _Rep1, class _Period, class _Rep2>
778struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
779 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
780{
781};
782
783template <class _Rep1, class _Period, class _Rep2>
784inline _LIBCPP_INLINE_VISIBILITY
785_LIBCPP_CONSTEXPR
786typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
787operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
788{
789 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
790 typedef duration<_Cr, _Period> _Cd;
791 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
792}
793
794template <class _Rep1, class _Period1, class _Rep2, class _Period2>
795inline _LIBCPP_INLINE_VISIBILITY
796_LIBCPP_CONSTEXPR
797typename common_type<_Rep1, _Rep2>::type
798operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
799{
800 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
801 return _Ct(__lhs).count() / _Ct(__rhs).count();
802}
803
804// Duration %
805
806template <class _Rep1, class _Period, class _Rep2>
807inline _LIBCPP_INLINE_VISIBILITY
808_LIBCPP_CONSTEXPR
809typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
810operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
811{
812 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
813 typedef duration<_Cr, _Period> _Cd;
814 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
815}
816
817template <class _Rep1, class _Period1, class _Rep2, class _Period2>
818inline _LIBCPP_INLINE_VISIBILITY
819_LIBCPP_CONSTEXPR
820typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
821operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
822{
823 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
824 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
825 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
826}
827
828//////////////////////////////////////////////////////////
829///////////////////// time_point /////////////////////////
830//////////////////////////////////////////////////////////
831
832template <class _Clock, class _Duration = typename _Clock::duration>
833class _LIBCPP_TEMPLATE_VIS time_point
834{
835 static_assert(__is_duration<_Duration>::value,
836 "Second template parameter of time_point must be a std::chrono::duration");
837public:
838 typedef _Clock clock;
839 typedef _Duration duration;
840 typedef typename duration::rep rep;
841 typedef typename duration::period period;
842private:
843 duration __d_;
844
845public:
846 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
847 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}
848
849 // conversions
850 template <class _Duration2>
851 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
852 time_point(const time_point<clock, _Duration2>& t,
853 typename enable_if
854 <
855 is_convertible<_Duration2, duration>::value
856 >::type* = 0)
857 : __d_(t.time_since_epoch()) {}
858
859 // observer
860
861 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}
862
863 // arithmetic
864
865 _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
866 _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
867
868 // special values
869
870 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
871 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
872};
873
874} // chrono
875
876template <class _Clock, class _Duration1, class _Duration2>
877struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
878 chrono::time_point<_Clock, _Duration2> >
879{
880 typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
881};
882
883namespace chrono {
884
885template <class _ToDuration, class _Clock, class _Duration>
886inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
887time_point<_Clock, _ToDuration>
888time_point_cast(const time_point<_Clock, _Duration>& __t)
889{
890 return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
891}
892
893#if _LIBCPP_STD_VER > 14
894template <class _ToDuration, class _Clock, class _Duration>
895inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
896typename enable_if
897<
898 __is_duration<_ToDuration>::value,
899 time_point<_Clock, _ToDuration>
900>::type
901floor(const time_point<_Clock, _Duration>& __t)
902{
903 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
904}
905
906template <class _ToDuration, class _Clock, class _Duration>
907inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
908typename enable_if
909<
910 __is_duration<_ToDuration>::value,
911 time_point<_Clock, _ToDuration>
912>::type
913ceil(const time_point<_Clock, _Duration>& __t)
914{
915 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
916}
917
918template <class _ToDuration, class _Clock, class _Duration>
919inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
920typename enable_if
921<
922 __is_duration<_ToDuration>::value,
923 time_point<_Clock, _ToDuration>
924>::type
925round(const time_point<_Clock, _Duration>& __t)
926{
927 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
928}
929
930template <class _Rep, class _Period>
931inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
932typename enable_if
933<
934 numeric_limits<_Rep>::is_signed,
935 duration<_Rep, _Period>
936>::type
937abs(duration<_Rep, _Period> __d)
938{
939 return __d >= __d.zero() ? __d : -__d;
940}
941#endif
942
943// time_point ==
944
945template <class _Clock, class _Duration1, class _Duration2>
946inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
947bool
948operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
949{
950 return __lhs.time_since_epoch() == __rhs.time_since_epoch();
951}
952
953// time_point !=
954
955template <class _Clock, class _Duration1, class _Duration2>
956inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
957bool
958operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
959{
960 return !(__lhs == __rhs);
961}
962
963// time_point <
964
965template <class _Clock, class _Duration1, class _Duration2>
966inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
967bool
968operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
969{
970 return __lhs.time_since_epoch() < __rhs.time_since_epoch();
971}
972
973// time_point >
974
975template <class _Clock, class _Duration1, class _Duration2>
976inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
977bool
978operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
979{
980 return __rhs < __lhs;
981}
982
983// time_point <=
984
985template <class _Clock, class _Duration1, class _Duration2>
986inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
987bool
988operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
989{
990 return !(__rhs < __lhs);
991}
992
993// time_point >=
994
995template <class _Clock, class _Duration1, class _Duration2>
996inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
997bool
998operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
999{
1000 return !(__lhs < __rhs);
1001}
1002
1003// time_point operator+(time_point x, duration y);
1004
1005template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1006inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1007time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1008operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1009{
1010 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
1011 return _Tr (__lhs.time_since_epoch() + __rhs);
1012}
1013
1014// time_point operator+(duration x, time_point y);
1015
1016template <class _Rep1, class _Period1, class _Clock, class _Duration2>
1017inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1018time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
1019operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1020{
1021 return __rhs + __lhs;
1022}
1023
1024// time_point operator-(time_point x, duration y);
1025
1026template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1027inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1028time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1029operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1030{
1031 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
1032 return _Ret(__lhs.time_since_epoch() -__rhs);
1033}
1034
1035// duration operator-(time_point x, time_point y);
1036
1037template <class _Clock, class _Duration1, class _Duration2>
1038inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1039typename common_type<_Duration1, _Duration2>::type
1040operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1041{
1042 return __lhs.time_since_epoch() - __rhs.time_since_epoch();
1043}
1044
1045//////////////////////////////////////////////////////////
1046/////////////////////// clocks ///////////////////////////
1047//////////////////////////////////////////////////////////
1048
1049class _LIBCPP_TYPE_VIS system_clock
1050{
1051public:
1052 typedef microseconds duration;
1053 typedef duration::rep rep;
1054 typedef duration::period period;
1055 typedef chrono::time_point<system_clock> time_point;
1056 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
1057
1058 static time_point now() _NOEXCEPT;
1059 static time_t to_time_t (const time_point& __t) _NOEXCEPT;
1060 static time_point from_time_t(time_t __t) _NOEXCEPT;
1061};
1062
1063#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
1064class _LIBCPP_TYPE_VIS steady_clock
1065{
1066public:
1067 typedef nanoseconds duration;
1068 typedef duration::rep rep;
1069 typedef duration::period period;
1070 typedef chrono::time_point<steady_clock, duration> time_point;
1071 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;
1072
1073 static time_point now() _NOEXCEPT;
1074};
1075
1076typedef steady_clock high_resolution_clock;
1077#else
1078typedef system_clock high_resolution_clock;
1079#endif
1080
1081} // chrono
1082
1083#if _LIBCPP_STD_VER > 11
1084// Suffixes for duration literals [time.duration.literals]
1085inline namespace literals
1086{
1087 inline namespace chrono_literals
1088 {
1089
1090 constexpr chrono::hours operator"" h(unsigned long long __h)
1091 {
1092 return chrono::hours(static_cast<chrono::hours::rep>(__h));
1093 }
1094
1095 constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long double __h)
1096 {
1097 return chrono::duration<long double, ratio<3600,1>>(__h);
1098 }
1099
1100
1101 constexpr chrono::minutes operator"" min(unsigned long long __m)
1102 {
1103 return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
1104 }
1105
1106 constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long double __m)
1107 {
1108 return chrono::duration<long double, ratio<60,1>> (__m);
1109 }
1110
1111
1112 constexpr chrono::seconds operator"" s(unsigned long long __s)
1113 {
1114 return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
1115 }
1116
1117 constexpr chrono::duration<long double> operator"" s(long double __s)
1118 {
1119 return chrono::duration<long double> (__s);
1120 }
1121
1122
1123 constexpr chrono::milliseconds operator"" ms(unsigned long long __ms)
1124 {
1125 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
1126 }
1127
1128 constexpr chrono::duration<long double, milli> operator"" ms(long double __ms)
1129 {
1130 return chrono::duration<long double, milli>(__ms);
1131 }
1132
1133
1134 constexpr chrono::microseconds operator"" us(unsigned long long __us)
1135 {
1136 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
1137 }
1138
1139 constexpr chrono::duration<long double, micro> operator"" us(long double __us)
1140 {
1141 return chrono::duration<long double, micro> (__us);
1142 }
1143
1144
1145 constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns)
1146 {
1147 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
1148 }
1149
1150 constexpr chrono::duration<long double, nano> operator"" ns(long double __ns)
1151 {
1152 return chrono::duration<long double, nano> (__ns);
1153 }
1154
1155}}
1156
1157namespace chrono { // hoist the literals into namespace std::chrono
1158 using namespace literals::chrono_literals;
1159}
1160
1161#endif
1162
1163_LIBCPP_END_NAMESPACE_STD
1164
1165_LIBCPP_POP_MACROS
1166
1167#endif // _LIBCPP_CHRONO