1// <chrono> -*- C++ -*- 
2 
3// Copyright (C) 2008-2019 Free Software Foundation, Inc. 
4// 
5// This file is part of the GNU ISO C++ Library. This library is free 
6// software; you can redistribute it and/or modify it under the 
7// terms of the GNU General Public License as published by the 
8// Free Software Foundation; either version 3, or (at your option) 
9// any later version. 
10 
11// This library is distributed in the hope that it will be useful, 
12// but WITHOUT ANY WARRANTY; without even the implied warranty of 
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
14// GNU General Public License for more details. 
15 
16// Under Section 7 of GPL version 3, you are granted additional 
17// permissions described in the GCC Runtime Library Exception, version 
18// 3.1, as published by the Free Software Foundation. 
19 
20// You should have received a copy of the GNU General Public License and 
21// a copy of the GCC Runtime Library Exception along with this program; 
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 
23// <http://www.gnu.org/licenses/>. 
24 
25/** @file include/chrono 
26 * This is a Standard C++ Library header. 
27 */ 
28 
29#ifndef _GLIBCXX_CHRONO 
30#define _GLIBCXX_CHRONO 1 
31 
32#pragma GCC system_header 
33 
34#if __cplusplus < 201103L 
35# include <bits/c++0x_warning.h> 
36#else 
37 
38#include <ratio> 
39#include <type_traits> 
40#include <limits> 
41#include <ctime> 
42#include <bits/parse_numbers.h> // for literals support. 
43 
44namespace std _GLIBCXX_VISIBILITY(default) 
45{ 
46_GLIBCXX_BEGIN_NAMESPACE_VERSION 
47 
48 /** 
49 * @defgroup chrono Time 
50 * @ingroup utilities 
51 * 
52 * Classes and functions for time. 
53 * @{ 
54 */ 
55 
56 /** @namespace std::chrono 
57 * @brief ISO C++ 2011 entities sub-namespace for time and date. 
58 */ 
59 namespace chrono 
60 { 
61 template<typename _Rep, typename _Period = ratio<1>> 
62 struct duration; 
63 
64 template<typename _Clock, typename _Dur = typename _Clock::duration> 
65 struct time_point; 
66 } 
67 
68 // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) 
69 
70 template<typename _CT, typename _Period1, typename _Period2> 
71 struct __duration_common_type_wrapper 
72 { 
73 private: 
74 typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num; 
75 typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den; 
76 typedef typename _CT::type __cr; 
77 typedef ratio<__gcd_num::value, 
78 (_Period1::den / __gcd_den::value) * _Period2::den> __r; 
79 public: 
80 typedef __success_type<chrono::duration<__cr, __r>> type; 
81 }; 
82 
83 template<typename _Period1, typename _Period2> 
84 struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2> 
85 { typedef __failure_type type; }; 
86 
87 template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> 
88 struct common_type<chrono::duration<_Rep1, _Period1>, 
89 chrono::duration<_Rep2, _Period2>> 
90 : public __duration_common_type_wrapper<typename __member_type_wrapper< 
91 common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type 
92 { }; 
93 
94 // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) 
95 
96 template<typename _CT, typename _Clock> 
97 struct __timepoint_common_type_wrapper 
98 { 
99 typedef __success_type<chrono::time_point<_Clock, typename _CT::type>> 
100 type; 
101 }; 
102 
103 template<typename _Clock> 
104 struct __timepoint_common_type_wrapper<__failure_type, _Clock> 
105 { typedef __failure_type type; }; 
106 
107 template<typename _Clock, typename _Duration1, typename _Duration2> 
108 struct common_type<chrono::time_point<_Clock, _Duration1>, 
109 chrono::time_point<_Clock, _Duration2>> 
110 : public __timepoint_common_type_wrapper<typename __member_type_wrapper< 
111 common_type<_Duration1, _Duration2>>::type, _Clock>::type 
112 { }; 
113 
114 namespace chrono 
115 { 
116 // Primary template for duration_cast impl. 
117 template<typename _ToDur, typename _CF, typename _CR, 
118 bool _NumIsOne = false, bool _DenIsOne = false> 
119 struct __duration_cast_impl 
120 { 
121 template<typename _Rep, typename _Period> 
122 static constexpr _ToDur 
123 __cast(const duration<_Rep, _Period>& __d) 
124 { 
125 typedef typename _ToDur::rep __to_rep; 
126 return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) 
127 * static_cast<_CR>(_CF::num) 
128 / static_cast<_CR>(_CF::den))); 
129 } 
130 }; 
131 
132 template<typename _ToDur, typename _CF, typename _CR> 
133 struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> 
134 { 
135 template<typename _Rep, typename _Period> 
136 static constexpr _ToDur 
137 __cast(const duration<_Rep, _Period>& __d) 
138 { 
139 typedef typename _ToDur::rep __to_rep; 
140 return _ToDur(static_cast<__to_rep>(__d.count())); 
141 } 
142 }; 
143 
144 template<typename _ToDur, typename _CF, typename _CR> 
145 struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> 
146 { 
147 template<typename _Rep, typename _Period> 
148 static constexpr _ToDur 
149 __cast(const duration<_Rep, _Period>& __d) 
150 { 
151 typedef typename _ToDur::rep __to_rep; 
152 return _ToDur(static_cast<__to_rep>( 
153 static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 
154 } 
155 }; 
156 
157 template<typename _ToDur, typename _CF, typename _CR> 
158 struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> 
159 { 
160 template<typename _Rep, typename _Period> 
161 static constexpr _ToDur 
162 __cast(const duration<_Rep, _Period>& __d) 
163 { 
164 typedef typename _ToDur::rep __to_rep; 
165 return _ToDur(static_cast<__to_rep>( 
166 static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); 
167 } 
168 }; 
169 
170 template<typename _Tp> 
171 struct __is_duration 
172 : std::false_type 
173 { }; 
174 
175 template<typename _Rep, typename _Period> 
176 struct __is_duration<duration<_Rep, _Period>> 
177 : std::true_type 
178 { }; 
179 
180 template<typename _Tp> 
181 using __enable_if_is_duration 
182 = typename enable_if<__is_duration<_Tp>::value, _Tp>::type; 
183 
184 template<typename _Tp> 
185 using __disable_if_is_duration 
186 = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type; 
187 
188 /// duration_cast 
189 template<typename _ToDur, typename _Rep, typename _Period> 
190 constexpr __enable_if_is_duration<_ToDur> 
191 duration_cast(const duration<_Rep, _Period>& __d) 
192 { 
193 typedef typename _ToDur::period __to_period; 
194 typedef typename _ToDur::rep __to_rep; 
195 typedef ratio_divide<_Period, __to_period> __cf; 
196 typedef typename common_type<__to_rep, _Rep, intmax_t>::type 
197 __cr; 
198 typedef __duration_cast_impl<_ToDur, __cf, __cr, 
199 __cf::num == 1, __cf::den == 1> __dc; 
200 return __dc::__cast(__d); 
201 } 
202 
203 /// treat_as_floating_point 
204 template<typename _Rep> 
205 struct treat_as_floating_point 
206 : is_floating_point<_Rep> 
207 { }; 
208 
209#if __cplusplus > 201402L 
210 template <typename _Rep> 
211 inline constexpr bool treat_as_floating_point_v = 
212 treat_as_floating_point<_Rep>::value; 
213#endif // C++17 
214 
215#if __cplusplus >= 201703L 
216# define __cpp_lib_chrono 201611 
217 
218 template<typename _ToDur, typename _Rep, typename _Period> 
219 constexpr __enable_if_is_duration<_ToDur> 
220 floor(const duration<_Rep, _Period>& __d) 
221 { 
222 auto __to = chrono::duration_cast<_ToDur>(__d); 
223 if (__to > __d) 
224 return __to - _ToDur{1}; 
225 return __to; 
226 } 
227 
228 template<typename _ToDur, typename _Rep, typename _Period> 
229 constexpr __enable_if_is_duration<_ToDur> 
230 ceil(const duration<_Rep, _Period>& __d) 
231 { 
232 auto __to = chrono::duration_cast<_ToDur>(__d); 
233 if (__to < __d) 
234 return __to + _ToDur{1}; 
235 return __to; 
236 } 
237 
238 template <typename _ToDur, typename _Rep, typename _Period> 
239 constexpr enable_if_t< 
240 __and_<__is_duration<_ToDur>, 
241 __not_<treat_as_floating_point<typename _ToDur::rep>>>::value, 
242 _ToDur> 
243 round(const duration<_Rep, _Period>& __d) 
244 { 
245 _ToDur __t0 = chrono::floor<_ToDur>(__d); 
246 _ToDur __t1 = __t0 + _ToDur{1}; 
247 auto __diff0 = __d - __t0; 
248 auto __diff1 = __t1 - __d; 
249 if (__diff0 == __diff1) 
250 { 
251 if (__t0.count() & 1) 
252 return __t1; 
253 return __t0; 
254 } 
255 else if (__diff0 < __diff1) 
256 return __t0; 
257 return __t1; 
258 } 
259 
260 template<typename _Rep, typename _Period> 
261 constexpr 
262 enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>> 
263 abs(duration<_Rep, _Period> __d) 
264 { 
265 if (__d >= __d.zero()) 
266 return __d; 
267 return -__d; 
268 } 
269#endif // C++17 
270 
271 /// duration_values 
272 template<typename _Rep> 
273 struct duration_values 
274 { 
275 static constexpr _Rep 
276 zero() noexcept 
277 { return _Rep(0); } 
278 
279 static constexpr _Rep 
280 max() noexcept 
281 { return numeric_limits<_Rep>::max(); } 
282 
283 static constexpr _Rep 
284 min() noexcept 
285 { return numeric_limits<_Rep>::lowest(); } 
286 }; 
287 
288 template<typename _Tp> 
289 struct __is_ratio 
290 : std::false_type 
291 { }; 
292 
293 template<intmax_t _Num, intmax_t _Den> 
294 struct __is_ratio<ratio<_Num, _Den>> 
295 : std::true_type 
296 { }; 
297 
298 /// duration 
299 template<typename _Rep, typename _Period> 
300 struct duration 
301 { 
302 private: 
303 template<typename _Rep2> 
304 using __is_float = treat_as_floating_point<_Rep2>; 
305 
306 // _Period2 is an exact multiple of _Period 
307 template<typename _Period2> 
308 using __is_harmonic 
309 = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>; 
310 
311 public: 
312 
313 typedef _Rep rep; 
314 typedef _Period period; 
315 
316 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); 
317 static_assert(__is_ratio<_Period>::value, 
318 "period must be a specialization of ratio"); 
319 static_assert(_Period::num > 0, "period must be positive"); 
320 
321 // 20.11.5.1 construction / copy / destroy 
322 constexpr duration() = default; 
323 
324 duration(const duration&) = default; 
325 
326 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
327 // 3050. Conversion specification problem in chrono::duration 
328 template<typename _Rep2, typename = _Require< 
329 is_convertible<const _Rep2&, rep>, 
330 __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>> 
331 constexpr explicit duration(const _Rep2& __rep) 
332 : __r(static_cast<rep>(__rep)) { } 
333 
334 template<typename _Rep2, typename _Period2, typename = _Require< 
335 __or_<__is_float<rep>, 
336 __and_<__is_harmonic<_Period2>, 
337 __not_<__is_float<_Rep2>>>>>> 
338 constexpr duration(const duration<_Rep2, _Period2>& __d) 
339 : __r(duration_cast<duration>(__d).count()) { } 
340 
341 ~duration() = default; 
342 duration& operator=(const duration&) = default; 
343 
344 // 20.11.5.2 observer 
345 constexpr rep 
346 count() const 
347 { return __r; } 
348 
349 // 20.11.5.3 arithmetic 
350 constexpr duration 
351 operator+() const 
352 { return *this; } 
353 
354 constexpr duration 
355 operator-() const 
356 { return duration(-__r); } 
357 
358 _GLIBCXX17_CONSTEXPR duration& 
359 operator++() 
360 { 
361 ++__r; 
362 return *this; 
363 } 
364 
365 _GLIBCXX17_CONSTEXPR duration 
366 operator++(int) 
367 { return duration(__r++); } 
368 
369 _GLIBCXX17_CONSTEXPR duration& 
370 operator--() 
371 { 
372 --__r; 
373 return *this; 
374 } 
375 
376 _GLIBCXX17_CONSTEXPR duration 
377 operator--(int) 
378 { return duration(__r--); } 
379 
380 _GLIBCXX17_CONSTEXPR duration& 
381 operator+=(const duration& __d) 
382 { 
383 __r += __d.count(); 
384 return *this; 
385 } 
386 
387 _GLIBCXX17_CONSTEXPR duration& 
388 operator-=(const duration& __d) 
389 { 
390 __r -= __d.count(); 
391 return *this; 
392 } 
393 
394 _GLIBCXX17_CONSTEXPR duration& 
395 operator*=(const rep& __rhs) 
396 { 
397 __r *= __rhs; 
398 return *this; 
399 } 
400 
401 _GLIBCXX17_CONSTEXPR duration& 
402 operator/=(const rep& __rhs) 
403 { 
404 __r /= __rhs; 
405 return *this; 
406 } 
407 
408 // DR 934. 
409 template<typename _Rep2 = rep> 
410 _GLIBCXX17_CONSTEXPR 
411 typename enable_if<!treat_as_floating_point<_Rep2>::value, 
412 duration&>::type 
413 operator%=(const rep& __rhs) 
414 { 
415 __r %= __rhs; 
416 return *this; 
417 } 
418 
419 template<typename _Rep2 = rep> 
420 _GLIBCXX17_CONSTEXPR 
421 typename enable_if<!treat_as_floating_point<_Rep2>::value, 
422 duration&>::type 
423 operator%=(const duration& __d) 
424 { 
425 __r %= __d.count(); 
426 return *this; 
427 } 
428 
429 // 20.11.5.4 special values 
430 static constexpr duration 
431 zero() noexcept 
432 { return duration(duration_values<rep>::zero()); } 
433 
434 static constexpr duration 
435 min() noexcept 
436 { return duration(duration_values<rep>::min()); } 
437 
438 static constexpr duration 
439 max() noexcept 
440 { return duration(duration_values<rep>::max()); } 
441 
442 private: 
443 rep __r; 
444 }; 
445 
446 template<typename _Rep1, typename _Period1, 
447 typename _Rep2, typename _Period2> 
448 constexpr typename common_type<duration<_Rep1, _Period1>, 
449 duration<_Rep2, _Period2>>::type 
450 operator+(const duration<_Rep1, _Period1>& __lhs, 
451 const duration<_Rep2, _Period2>& __rhs) 
452 { 
453 typedef duration<_Rep1, _Period1> __dur1; 
454 typedef duration<_Rep2, _Period2> __dur2; 
455 typedef typename common_type<__dur1,__dur2>::type __cd; 
456 return __cd(__cd(__lhs).count() + __cd(__rhs).count()); 
457 } 
458 
459 template<typename _Rep1, typename _Period1, 
460 typename _Rep2, typename _Period2> 
461 constexpr typename common_type<duration<_Rep1, _Period1>, 
462 duration<_Rep2, _Period2>>::type 
463 operator-(const duration<_Rep1, _Period1>& __lhs, 
464 const duration<_Rep2, _Period2>& __rhs) 
465 { 
466 typedef duration<_Rep1, _Period1> __dur1; 
467 typedef duration<_Rep2, _Period2> __dur2; 
468 typedef typename common_type<__dur1,__dur2>::type __cd; 
469 return __cd(__cd(__lhs).count() - __cd(__rhs).count()); 
470 } 
471 
472 // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2 
473 // is implicitly convertible to it. 
474 // _GLIBCXX_RESOLVE_LIB_DEFECTS 
475 // 3050. Conversion specification problem in chrono::duration constructor 
476 template<typename _Rep1, typename _Rep2, 
477 typename _CRep = typename common_type<_Rep1, _Rep2>::type> 
478 using __common_rep_t = typename 
479 enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type; 
480 
481 template<typename _Rep1, typename _Period, typename _Rep2> 
482 constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> 
483 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 
484 { 
485 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 
486 __cd; 
487 return __cd(__cd(__d).count() * __s); 
488 } 
489 
490 template<typename _Rep1, typename _Rep2, typename _Period> 
491 constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period> 
492 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 
493 { return __d * __s; } 
494 
495 template<typename _Rep1, typename _Period, typename _Rep2> 
496 constexpr 
497 duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> 
498 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 
499 { 
500 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 
501 __cd; 
502 return __cd(__cd(__d).count() / __s); 
503 } 
504 
505 template<typename _Rep1, typename _Period1, 
506 typename _Rep2, typename _Period2> 
507 constexpr typename common_type<_Rep1, _Rep2>::type 
508 operator/(const duration<_Rep1, _Period1>& __lhs, 
509 const duration<_Rep2, _Period2>& __rhs) 
510 { 
511 typedef duration<_Rep1, _Period1> __dur1; 
512 typedef duration<_Rep2, _Period2> __dur2; 
513 typedef typename common_type<__dur1,__dur2>::type __cd; 
514 return __cd(__lhs).count() / __cd(__rhs).count(); 
515 } 
516 
517 // DR 934. 
518 template<typename _Rep1, typename _Period, typename _Rep2> 
519 constexpr 
520 duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> 
521 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 
522 { 
523 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 
524 __cd; 
525 return __cd(__cd(__d).count() % __s); 
526 } 
527 
528 template<typename _Rep1, typename _Period1, 
529 typename _Rep2, typename _Period2> 
530 constexpr typename common_type<duration<_Rep1, _Period1>, 
531 duration<_Rep2, _Period2>>::type 
532 operator%(const duration<_Rep1, _Period1>& __lhs, 
533 const duration<_Rep2, _Period2>& __rhs) 
534 { 
535 typedef duration<_Rep1, _Period1> __dur1; 
536 typedef duration<_Rep2, _Period2> __dur2; 
537 typedef typename common_type<__dur1,__dur2>::type __cd; 
538 return __cd(__cd(__lhs).count() % __cd(__rhs).count()); 
539 } 
540 
541 // comparisons 
542 template<typename _Rep1, typename _Period1, 
543 typename _Rep2, typename _Period2> 
544 constexpr bool 
545 operator==(const duration<_Rep1, _Period1>& __lhs, 
546 const duration<_Rep2, _Period2>& __rhs) 
547 { 
548 typedef duration<_Rep1, _Period1> __dur1; 
549 typedef duration<_Rep2, _Period2> __dur2; 
550 typedef typename common_type<__dur1,__dur2>::type __ct; 
551 return __ct(__lhs).count() == __ct(__rhs).count(); 
552 } 
553 
554 template<typename _Rep1, typename _Period1, 
555 typename _Rep2, typename _Period2> 
556 constexpr bool 
557 operator<(const duration<_Rep1, _Period1>& __lhs, 
558 const duration<_Rep2, _Period2>& __rhs) 
559 { 
560 typedef duration<_Rep1, _Period1> __dur1; 
561 typedef duration<_Rep2, _Period2> __dur2; 
562 typedef typename common_type<__dur1,__dur2>::type __ct; 
563 return __ct(__lhs).count() < __ct(__rhs).count(); 
564 } 
565 
566 template<typename _Rep1, typename _Period1, 
567 typename _Rep2, typename _Period2> 
568 constexpr bool 
569 operator!=(const duration<_Rep1, _Period1>& __lhs, 
570 const duration<_Rep2, _Period2>& __rhs) 
571 { return !(__lhs == __rhs); } 
572 
573 template<typename _Rep1, typename _Period1, 
574 typename _Rep2, typename _Period2> 
575 constexpr bool 
576 operator<=(const duration<_Rep1, _Period1>& __lhs, 
577 const duration<_Rep2, _Period2>& __rhs) 
578 { return !(__rhs < __lhs); } 
579 
580 template<typename _Rep1, typename _Period1, 
581 typename _Rep2, typename _Period2> 
582 constexpr bool 
583 operator>(const duration<_Rep1, _Period1>& __lhs, 
584 const duration<_Rep2, _Period2>& __rhs) 
585 { return __rhs < __lhs; } 
586 
587 template<typename _Rep1, typename _Period1, 
588 typename _Rep2, typename _Period2> 
589 constexpr bool 
590 operator>=(const duration<_Rep1, _Period1>& __lhs, 
591 const duration<_Rep2, _Period2>& __rhs) 
592 { return !(__lhs < __rhs); } 
593 
594#ifdef _GLIBCXX_USE_C99_STDINT_TR1 
595# define _GLIBCXX_CHRONO_INT64_T int64_t 
596#elif defined __INT64_TYPE__ 
597# define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__ 
598#else 
599 static_assert(std::numeric_limits<unsigned long long>::digits >= 64, 
600 "Representation type for nanoseconds must have at least 64 bits"); 
601# define _GLIBCXX_CHRONO_INT64_T long long 
602#endif 
603 
604 /// nanoseconds 
605 typedef duration<_GLIBCXX_CHRONO_INT64_T, nano> nanoseconds; 
606 
607 /// microseconds 
608 typedef duration<_GLIBCXX_CHRONO_INT64_T, micro> microseconds; 
609 
610 /// milliseconds 
611 typedef duration<_GLIBCXX_CHRONO_INT64_T, milli> milliseconds; 
612 
613 /// seconds 
614 typedef duration<_GLIBCXX_CHRONO_INT64_T> seconds; 
615 
616 /// minutes 
617 typedef duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>> minutes; 
618 
619 /// hours 
620 typedef duration<_GLIBCXX_CHRONO_INT64_T, ratio<3600>> hours; 
621 
622#undef _GLIBCXX_CHRONO_INT64_T 
623 
624 /// time_point 
625 template<typename _Clock, typename _Dur> 
626 struct time_point 
627 { 
628 typedef _Clock clock; 
629 typedef _Dur duration; 
630 typedef typename duration::rep rep; 
631 typedef typename duration::period period; 
632 
633 constexpr time_point() : __d(duration::zero()) 
634 { } 
635 
636 constexpr explicit time_point(const duration& __dur) 
637 : __d(__dur) 
638 { } 
639 
640 // conversions 
641 template<typename _Dur2, 
642 typename = _Require<is_convertible<_Dur2, _Dur>>> 
643 constexpr time_point(const time_point<clock, _Dur2>& __t) 
644 : __d(__t.time_since_epoch()) 
645 { } 
646 
647 // observer 
648 constexpr duration 
649 time_since_epoch() const 
650 { return __d; } 
651 
652 // arithmetic 
653 _GLIBCXX17_CONSTEXPR time_point& 
654 operator+=(const duration& __dur) 
655 { 
656 __d += __dur; 
657 return *this; 
658 } 
659 
660 _GLIBCXX17_CONSTEXPR time_point& 
661 operator-=(const duration& __dur) 
662 { 
663 __d -= __dur; 
664 return *this; 
665 } 
666 
667 // special values 
668 static constexpr time_point 
669 min() noexcept 
670 { return time_point(duration::min()); } 
671 
672 static constexpr time_point 
673 max() noexcept 
674 { return time_point(duration::max()); } 
675 
676 private: 
677 duration __d; 
678 }; 
679 
680 /// time_point_cast 
681 template<typename _ToDur, typename _Clock, typename _Dur> 
682 constexpr typename enable_if<__is_duration<_ToDur>::value, 
683 time_point<_Clock, _ToDur>>::type 
684 time_point_cast(const time_point<_Clock, _Dur>& __t) 
685 { 
686 typedef time_point<_Clock, _ToDur> __time_point; 
687 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); 
688 } 
689 
690#if __cplusplus > 201402L 
691 template<typename _ToDur, typename _Clock, typename _Dur> 
692 constexpr 
693 enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> 
694 floor(const time_point<_Clock, _Dur>& __tp) 
695 { 
696 return time_point<_Clock, _ToDur>{ 
697 chrono::floor<_ToDur>(__tp.time_since_epoch())}; 
698 } 
699 
700 template<typename _ToDur, typename _Clock, typename _Dur> 
701 constexpr 
702 enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> 
703 ceil(const time_point<_Clock, _Dur>& __tp) 
704 { 
705 return time_point<_Clock, _ToDur>{ 
706 chrono::ceil<_ToDur>(__tp.time_since_epoch())}; 
707 } 
708 
709 template<typename _ToDur, typename _Clock, typename _Dur> 
710 constexpr enable_if_t< 
711 __and_<__is_duration<_ToDur>, 
712 __not_<treat_as_floating_point<typename _ToDur::rep>>>::value, 
713 time_point<_Clock, _ToDur>> 
714 round(const time_point<_Clock, _Dur>& __tp) 
715 { 
716 return time_point<_Clock, _ToDur>{ 
717 chrono::round<_ToDur>(__tp.time_since_epoch())}; 
718 } 
719#endif // C++17 
720 
721 template<typename _Clock, typename _Dur1, 
722 typename _Rep2, typename _Period2> 
723 constexpr time_point<_Clock, 
724 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 
725 operator+(const time_point<_Clock, _Dur1>& __lhs, 
726 const duration<_Rep2, _Period2>& __rhs) 
727 { 
728 typedef duration<_Rep2, _Period2> __dur2; 
729 typedef typename common_type<_Dur1,__dur2>::type __ct; 
730 typedef time_point<_Clock, __ct> __time_point; 
731 return __time_point(__lhs.time_since_epoch() + __rhs); 
732 } 
733 
734 template<typename _Rep1, typename _Period1, 
735 typename _Clock, typename _Dur2> 
736 constexpr time_point<_Clock, 
737 typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> 
738 operator+(const duration<_Rep1, _Period1>& __lhs, 
739 const time_point<_Clock, _Dur2>& __rhs) 
740 { 
741 typedef duration<_Rep1, _Period1> __dur1; 
742 typedef typename common_type<__dur1,_Dur2>::type __ct; 
743 typedef time_point<_Clock, __ct> __time_point; 
744 return __time_point(__rhs.time_since_epoch() + __lhs); 
745 } 
746 
747 template<typename _Clock, typename _Dur1, 
748 typename _Rep2, typename _Period2> 
749 constexpr time_point<_Clock, 
750 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 
751 operator-(const time_point<_Clock, _Dur1>& __lhs, 
752 const duration<_Rep2, _Period2>& __rhs) 
753 { 
754 typedef duration<_Rep2, _Period2> __dur2; 
755 typedef typename common_type<_Dur1,__dur2>::type __ct; 
756 typedef time_point<_Clock, __ct> __time_point; 
757 return __time_point(__lhs.time_since_epoch() -__rhs); 
758 } 
759 
760 template<typename _Clock, typename _Dur1, typename _Dur2> 
761 constexpr typename common_type<_Dur1, _Dur2>::type 
762 operator-(const time_point<_Clock, _Dur1>& __lhs, 
763 const time_point<_Clock, _Dur2>& __rhs) 
764 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } 
765 
766 template<typename _Clock, typename _Dur1, typename _Dur2> 
767 constexpr bool 
768 operator==(const time_point<_Clock, _Dur1>& __lhs, 
769 const time_point<_Clock, _Dur2>& __rhs) 
770 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } 
771 
772 template<typename _Clock, typename _Dur1, typename _Dur2> 
773 constexpr bool 
774 operator!=(const time_point<_Clock, _Dur1>& __lhs, 
775 const time_point<_Clock, _Dur2>& __rhs) 
776 { return !(__lhs == __rhs); } 
777 
778 template<typename _Clock, typename _Dur1, typename _Dur2> 
779 constexpr bool 
780 operator<(const time_point<_Clock, _Dur1>& __lhs, 
781 const time_point<_Clock, _Dur2>& __rhs) 
782 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } 
783 
784 template<typename _Clock, typename _Dur1, typename _Dur2> 
785 constexpr bool 
786 operator<=(const time_point<_Clock, _Dur1>& __lhs, 
787 const time_point<_Clock, _Dur2>& __rhs) 
788 { return !(__rhs < __lhs); } 
789 
790 template<typename _Clock, typename _Dur1, typename _Dur2> 
791 constexpr bool 
792 operator>(const time_point<_Clock, _Dur1>& __lhs, 
793 const time_point<_Clock, _Dur2>& __rhs) 
794 { return __rhs < __lhs; } 
795 
796 template<typename _Clock, typename _Dur1, typename _Dur2> 
797 constexpr bool 
798 operator>=(const time_point<_Clock, _Dur1>& __lhs, 
799 const time_point<_Clock, _Dur2>& __rhs) 
800 { return !(__lhs < __rhs); } 
801 
802 
803 // Clocks. 
804 
805 // Why nanosecond resolution as the default? 
806 // Why have std::system_clock always count in the highest 
807 // resolution (ie nanoseconds), even if on some OSes the low 3 
808 // or 9 decimal digits will be always zero? This allows later 
809 // implementations to change the system_clock::now() 
810 // implementation any time to provide better resolution without 
811 // changing function signature or units. 
812 
813 // To support the (forward) evolution of the library's defined 
814 // clocks, wrap inside inline namespace so that the current 
815 // defintions of system_clock, steady_clock, and 
816 // high_resolution_clock types are uniquely mangled. This way, new 
817 // code can use the latests clocks, while the library can contain 
818 // compatibility definitions for previous versions. At some 
819 // point, when these clocks settle down, the inlined namespaces 
820 // can be removed. XXX GLIBCXX_ABI Deprecated 
821 inline namespace _V2 { 
822 
823 /** 
824 * @brief System clock. 
825 * 
826 * Time returned represents wall time from the system-wide clock. 
827 */ 
828 struct system_clock 
829 { 
830 typedef chrono::nanoseconds duration; 
831 typedef duration::rep rep; 
832 typedef duration::period period; 
833 typedef chrono::time_point<system_clock, duration> time_point; 
834 
835 static_assert(system_clock::duration::min() 
836 < system_clock::duration::zero(), 
837 "a clock's minimum duration cannot be less than its epoch"); 
838 
839 static constexpr bool is_steady = false; 
840 
841 static time_point 
842 now() noexcept; 
843 
844 // Map to C API 
845 static std::time_t 
846 to_time_t(const time_point& __t) noexcept 
847 { 
848 return std::time_t(duration_cast<chrono::seconds> 
849 (__t.time_since_epoch()).count()); 
850 } 
851 
852 static time_point 
853 from_time_t(std::time_t __t) noexcept 
854 { 
855 typedef chrono::time_point<system_clock, seconds> __from; 
856 return time_point_cast<system_clock::duration> 
857 (__from(chrono::seconds(__t))); 
858 } 
859 }; 
860 
861 
862 /** 
863 * @brief Monotonic clock 
864 * 
865 * Time returned has the property of only increasing at a uniform rate. 
866 */ 
867 struct steady_clock 
868 { 
869 typedef chrono::nanoseconds duration; 
870 typedef duration::rep rep; 
871 typedef duration::period period; 
872 typedef chrono::time_point<steady_clock, duration> time_point; 
873 
874 static constexpr bool is_steady = true; 
875 
876 static time_point 
877 now() noexcept; 
878 }; 
879 
880 
881 /** 
882 * @brief Highest-resolution clock 
883 * 
884 * This is the clock "with the shortest tick period." Alias to 
885 * std::system_clock until higher-than-nanosecond definitions 
886 * become feasible. 
887 */ 
888 using high_resolution_clock = system_clock; 
889 
890 } // end inline namespace _V2 
891 } // namespace chrono 
892 
893#if __cplusplus > 201103L 
894 
895#define __cpp_lib_chrono_udls 201304 
896 
897 inline namespace literals 
898 { 
899 inline namespace chrono_literals 
900 { 
901#pragma GCC diagnostic push 
902#pragma GCC diagnostic ignored "-Wliteral-suffix" 
903 template<typename _Dur, char... _Digits> 
904 constexpr _Dur __check_overflow() 
905 { 
906 using _Val = __parse_int::_Parse_int<_Digits...>; 
907 constexpr typename _Dur::rep __repval = _Val::value; 
908 static_assert(__repval >= 0 && __repval == _Val::value, 
909 "literal value cannot be represented by duration type"); 
910 return _Dur(__repval); 
911 } 
912 
913 constexpr chrono::duration<long double, ratio<3600,1>> 
914 operator""h(long double __hours) 
915 { return chrono::duration<long double, ratio<3600,1>>{__hours}; } 
916 
917 template <char... _Digits> 
918 constexpr chrono::hours 
919 operator""h() 
920 { return __check_overflow<chrono::hours, _Digits...>(); } 
921 
922 constexpr chrono::duration<long double, ratio<60,1>> 
923 operator""min(long double __mins) 
924 { return chrono::duration<long double, ratio<60,1>>{__mins}; } 
925 
926 template <char... _Digits> 
927 constexpr chrono::minutes 
928 operator""min() 
929 { return __check_overflow<chrono::minutes, _Digits...>(); } 
930 
931 constexpr chrono::duration<long double> 
932 operator""s(long double __secs) 
933 { return chrono::duration<long double>{__secs}; } 
934 
935 template <char... _Digits> 
936 constexpr chrono::seconds 
937 operator""s() 
938 { return __check_overflow<chrono::seconds, _Digits...>(); } 
939 
940 constexpr chrono::duration<long double, milli> 
941 operator""ms(long double __msecs) 
942 { return chrono::duration<long double, milli>{__msecs}; } 
943 
944 template <char... _Digits> 
945 constexpr chrono::milliseconds 
946 operator""ms() 
947 { return __check_overflow<chrono::milliseconds, _Digits...>(); } 
948 
949 constexpr chrono::duration<long double, micro> 
950 operator""us(long double __usecs) 
951 { return chrono::duration<long double, micro>{__usecs}; } 
952 
953 template <char... _Digits> 
954 constexpr chrono::microseconds 
955 operator""us() 
956 { return __check_overflow<chrono::microseconds, _Digits...>(); } 
957 
958 constexpr chrono::duration<long double, nano> 
959 operator""ns(long double __nsecs) 
960 { return chrono::duration<long double, nano>{__nsecs}; } 
961 
962 template <char... _Digits> 
963 constexpr chrono::nanoseconds 
964 operator""ns() 
965 { return __check_overflow<chrono::nanoseconds, _Digits...>(); } 
966 
967#pragma GCC diagnostic pop 
968 } // inline namespace chrono_literals 
969 } // inline namespace literals 
970 
971 namespace chrono 
972 { 
973 using namespace literals::chrono_literals; 
974 } // namespace chrono 
975 
976#endif // C++14 
977 
978 // @} group chrono 
979 
980_GLIBCXX_END_NAMESPACE_VERSION 
981} // namespace std 
982 
983#endif // C++11 
984 
985#endif //_GLIBCXX_CHRONO 
986