1// <chrono> -*- C++ -*-
2
3// Copyright (C) 2008-2015 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
44#ifdef _GLIBCXX_USE_C99_STDINT_TR1
45
46namespace std _GLIBCXX_VISIBILITY(default)
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 _GLIBCXX_BEGIN_NAMESPACE_VERSION
62
63 template<typename _Rep, typename _Period = ratio<1>>
64 struct duration;
65
66 template<typename _Clock, typename _Dur = typename _Clock::duration>
67 struct time_point;
68
69 _GLIBCXX_END_NAMESPACE_VERSION
70 }
71
72_GLIBCXX_BEGIN_NAMESPACE_VERSION
73
74 // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
75
76 template<typename _CT, typename _Period1, typename _Period2>
77 struct __duration_common_type_wrapper
78 {
79 private:
80 typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
81 typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
82 typedef typename _CT::type __cr;
83 typedef ratio<__gcd_num::value,
84 (_Period1::den / __gcd_den::value) * _Period2::den> __r;
85 public:
86 typedef __success_type<chrono::duration<__cr, __r>> type;
87 };
88
89 template<typename _Period1, typename _Period2>
90 struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
91 { typedef __failure_type type; };
92
93 template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
94 struct common_type<chrono::duration<_Rep1, _Period1>,
95 chrono::duration<_Rep2, _Period2>>
96 : public __duration_common_type_wrapper<typename __member_type_wrapper<
97 common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
98 { };
99
100 // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
101
102 template<typename _CT, typename _Clock>
103 struct __timepoint_common_type_wrapper
104 {
105 typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
106 type;
107 };
108
109 template<typename _Clock>
110 struct __timepoint_common_type_wrapper<__failure_type, _Clock>
111 { typedef __failure_type type; };
112
113 template<typename _Clock, typename _Duration1, typename _Duration2>
114 struct common_type<chrono::time_point<_Clock, _Duration1>,
115 chrono::time_point<_Clock, _Duration2>>
116 : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
117 common_type<_Duration1, _Duration2>>::type, _Clock>::type
118 { };
119
120_GLIBCXX_END_NAMESPACE_VERSION
121
122 namespace chrono
123 {
124 _GLIBCXX_BEGIN_NAMESPACE_VERSION
125
126 // Primary template for duration_cast impl.
127 template<typename _ToDur, typename _CF, typename _CR,
128 bool _NumIsOne = false, bool _DenIsOne = false>
129 struct __duration_cast_impl
130 {
131 template<typename _Rep, typename _Period>
132 static constexpr _ToDur
133 __cast(const duration<_Rep, _Period>& __d)
134 {
135 typedef typename _ToDur::rep __to_rep;
136 return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
137 * static_cast<_CR>(_CF::num)
138 / static_cast<_CR>(_CF::den)));
139 }
140 };
141
142 template<typename _ToDur, typename _CF, typename _CR>
143 struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
144 {
145 template<typename _Rep, typename _Period>
146 static constexpr _ToDur
147 __cast(const duration<_Rep, _Period>& __d)
148 {
149 typedef typename _ToDur::rep __to_rep;
150 return _ToDur(static_cast<__to_rep>(__d.count()));
151 }
152 };
153
154 template<typename _ToDur, typename _CF, typename _CR>
155 struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
156 {
157 template<typename _Rep, typename _Period>
158 static constexpr _ToDur
159 __cast(const duration<_Rep, _Period>& __d)
160 {
161 typedef typename _ToDur::rep __to_rep;
162 return _ToDur(static_cast<__to_rep>(
163 static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
164 }
165 };
166
167 template<typename _ToDur, typename _CF, typename _CR>
168 struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
169 {
170 template<typename _Rep, typename _Period>
171 static constexpr _ToDur
172 __cast(const duration<_Rep, _Period>& __d)
173 {
174 typedef typename _ToDur::rep __to_rep;
175 return _ToDur(static_cast<__to_rep>(
176 static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
177 }
178 };
179
180 template<typename _Tp>
181 struct __is_duration
182 : std::false_type
183 { };
184
185 template<typename _Rep, typename _Period>
186 struct __is_duration<duration<_Rep, _Period>>
187 : std::true_type
188 { };
189
190 /// duration_cast
191 template<typename _ToDur, typename _Rep, typename _Period>
192 constexpr typename enable_if<__is_duration<_ToDur>::value,
193 _ToDur>::type
194 duration_cast(const duration<_Rep, _Period>& __d)
195 {
196 typedef typename _ToDur::period __to_period;
197 typedef typename _ToDur::rep __to_rep;
198 typedef ratio_divide<_Period, __to_period> __cf;
199 typedef typename common_type<__to_rep, _Rep, intmax_t>::type
200 __cr;
201 typedef __duration_cast_impl<_ToDur, __cf, __cr,
202 __cf::num == 1, __cf::den == 1> __dc;
203 return __dc::__cast(__d);
204 }
205
206 /// treat_as_floating_point
207 template<typename _Rep>
208 struct treat_as_floating_point
209 : is_floating_point<_Rep>
210 { };
211
212 /// duration_values
213 template<typename _Rep>
214 struct duration_values
215 {
216 static constexpr _Rep
217 zero()
218 { return _Rep(0); }
219
220 static constexpr _Rep
221 max()
222 { return numeric_limits<_Rep>::max(); }
223
224 static constexpr _Rep
225 min()
226 { return numeric_limits<_Rep>::lowest(); }
227 };
228
229 template<typename _Tp>
230 struct __is_ratio
231 : std::false_type
232 { };
233
234 template<intmax_t _Num, intmax_t _Den>
235 struct __is_ratio<ratio<_Num, _Den>>
236 : std::true_type
237 { };
238
239 /// duration
240 template<typename _Rep, typename _Period>
241 struct duration
242 {
243 typedef _Rep rep;
244 typedef _Period period;
245
246 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
247 static_assert(__is_ratio<_Period>::value,
248 "period must be a specialization of ratio");
249 static_assert(_Period::num > 0, "period must be positive");
250
251 // 20.11.5.1 construction / copy / destroy
252 constexpr duration() = default;
253
254 // NB: Make constexpr implicit. This cannot be explicitly
255 // constexpr, as any UDT that is not a literal type with a
256 // constexpr copy constructor will be ill-formed.
257 duration(const duration&) = default;
258
259 template<typename _Rep2, typename = typename
260 enable_if<is_convertible<_Rep2, rep>::value
261 && (treat_as_floating_point<rep>::value
262 || !treat_as_floating_point<_Rep2>::value)>::type>
263 constexpr explicit duration(const _Rep2& __rep)
264 : __r(static_cast<rep>(__rep)) { }
265
266 template<typename _Rep2, typename _Period2, typename = typename
267 enable_if<treat_as_floating_point<rep>::value
268 || (ratio_divide<_Period2, period>::den == 1
269 && !treat_as_floating_point<_Rep2>::value)>::type>
270 constexpr duration(const duration<_Rep2, _Period2>& __d)
271 : __r(duration_cast<duration>(__d).count()) { }
272
273 ~duration() = default;
274 duration& operator=(const duration&) = default;
275
276 // 20.11.5.2 observer
277 constexpr rep
278 count() const
279 { return __r; }
280
281 // 20.11.5.3 arithmetic
282 constexpr duration
283 operator+() const
284 { return *this; }
285
286 constexpr duration
287 operator-() const
288 { return duration(-__r); }
289
290 duration&
291 operator++()
292 {
293 ++__r;
294 return *this;
295 }
296
297 duration
298 operator++(int)
299 { return duration(__r++); }
300
301 duration&
302 operator--()
303 {
304 --__r;
305 return *this;
306 }
307
308 duration
309 operator--(int)
310 { return duration(__r--); }
311
312 duration&
313 operator+=(const duration& __d)
314 {
315 __r += __d.count();
316 return *this;
317 }
318
319 duration&
320 operator-=(const duration& __d)
321 {
322 __r -= __d.count();
323 return *this;
324 }
325
326 duration&
327 operator*=(const rep& __rhs)
328 {
329 __r *= __rhs;
330 return *this;
331 }
332
333 duration&
334 operator/=(const rep& __rhs)
335 {
336 __r /= __rhs;
337 return *this;
338 }
339
340 // DR 934.
341 template<typename _Rep2 = rep>
342 typename enable_if<!treat_as_floating_point<_Rep2>::value,
343 duration&>::type
344 operator%=(const rep& __rhs)
345 {
346 __r %= __rhs;
347 return *this;
348 }
349
350 template<typename _Rep2 = rep>
351 typename enable_if<!treat_as_floating_point<_Rep2>::value,
352 duration&>::type
353 operator%=(const duration& __d)
354 {
355 __r %= __d.count();
356 return *this;
357 }
358
359 // 20.11.5.4 special values
360 static constexpr duration
361 zero()
362 { return duration(duration_values<rep>::zero()); }
363
364 static constexpr duration
365 min()
366 { return duration(duration_values<rep>::min()); }
367
368 static constexpr duration
369 max()
370 { return duration(duration_values<rep>::max()); }
371
372 private:
373 rep __r;
374 };
375
376 template<typename _Rep1, typename _Period1,
377 typename _Rep2, typename _Period2>
378 constexpr typename common_type<duration<_Rep1, _Period1>,
379 duration<_Rep2, _Period2>>::type
380 operator+(const duration<_Rep1, _Period1>& __lhs,
381 const duration<_Rep2, _Period2>& __rhs)
382 {
383 typedef duration<_Rep1, _Period1> __dur1;
384 typedef duration<_Rep2, _Period2> __dur2;
385 typedef typename common_type<__dur1,__dur2>::type __cd;
386 return __cd(__cd(__lhs).count() + __cd(__rhs).count());
387 }
388
389 template<typename _Rep1, typename _Period1,
390 typename _Rep2, typename _Period2>
391 constexpr typename common_type<duration<_Rep1, _Period1>,
392 duration<_Rep2, _Period2>>::type
393 operator-(const duration<_Rep1, _Period1>& __lhs,
394 const duration<_Rep2, _Period2>& __rhs)
395 {
396 typedef duration<_Rep1, _Period1> __dur1;
397 typedef duration<_Rep2, _Period2> __dur2;
398 typedef typename common_type<__dur1,__dur2>::type __cd;
399 return __cd(__cd(__lhs).count() - __cd(__rhs).count());
400 }
401
402 template<typename _Rep1, typename _Rep2, bool =
403 is_convertible<_Rep2,
404 typename common_type<_Rep1, _Rep2>::type>::value>
405 struct __common_rep_type { };
406
407 template<typename _Rep1, typename _Rep2>
408 struct __common_rep_type<_Rep1, _Rep2, true>
409 { typedef typename common_type<_Rep1, _Rep2>::type type; };
410
411 template<typename _Rep1, typename _Period, typename _Rep2>
412 constexpr
413 duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
414 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
415 {
416 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
417 __cd;
418 return __cd(__cd(__d).count() * __s);
419 }
420
421 template<typename _Rep1, typename _Rep2, typename _Period>
422 constexpr
423 duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
424 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
425 { return __d * __s; }
426
427 template<typename _Rep1, typename _Period, typename _Rep2>
428 constexpr duration<typename __common_rep_type<_Rep1, typename
429 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
430 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
431 {
432 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
433 __cd;
434 return __cd(__cd(__d).count() / __s);
435 }
436
437 template<typename _Rep1, typename _Period1,
438 typename _Rep2, typename _Period2>
439 constexpr typename common_type<_Rep1, _Rep2>::type
440 operator/(const duration<_Rep1, _Period1>& __lhs,
441 const duration<_Rep2, _Period2>& __rhs)
442 {
443 typedef duration<_Rep1, _Period1> __dur1;
444 typedef duration<_Rep2, _Period2> __dur2;
445 typedef typename common_type<__dur1,__dur2>::type __cd;
446 return __cd(__lhs).count() / __cd(__rhs).count();
447 }
448
449 // DR 934.
450 template<typename _Rep1, typename _Period, typename _Rep2>
451 constexpr duration<typename __common_rep_type<_Rep1, typename
452 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
453 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
454 {
455 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
456 __cd;
457 return __cd(__cd(__d).count() % __s);
458 }
459
460 template<typename _Rep1, typename _Period1,
461 typename _Rep2, typename _Period2>
462 constexpr typename common_type<duration<_Rep1, _Period1>,
463 duration<_Rep2, _Period2>>::type
464 operator%(const duration<_Rep1, _Period1>& __lhs,
465 const duration<_Rep2, _Period2>& __rhs)
466 {
467 typedef duration<_Rep1, _Period1> __dur1;
468 typedef duration<_Rep2, _Period2> __dur2;
469 typedef typename common_type<__dur1,__dur2>::type __cd;
470 return __cd(__cd(__lhs).count() % __cd(__rhs).count());
471 }
472
473 // comparisons
474 template<typename _Rep1, typename _Period1,
475 typename _Rep2, typename _Period2>
476 constexpr bool
477 operator==(const duration<_Rep1, _Period1>& __lhs,
478 const duration<_Rep2, _Period2>& __rhs)
479 {
480 typedef duration<_Rep1, _Period1> __dur1;
481 typedef duration<_Rep2, _Period2> __dur2;
482 typedef typename common_type<__dur1,__dur2>::type __ct;
483 return __ct(__lhs).count() == __ct(__rhs).count();
484 }
485
486 template<typename _Rep1, typename _Period1,
487 typename _Rep2, typename _Period2>
488 constexpr bool
489 operator<(const duration<_Rep1, _Period1>& __lhs,
490 const duration<_Rep2, _Period2>& __rhs)
491 {
492 typedef duration<_Rep1, _Period1> __dur1;
493 typedef duration<_Rep2, _Period2> __dur2;
494 typedef typename common_type<__dur1,__dur2>::type __ct;
495 return __ct(__lhs).count() < __ct(__rhs).count();
496 }
497
498 template<typename _Rep1, typename _Period1,
499 typename _Rep2, typename _Period2>
500 constexpr bool
501 operator!=(const duration<_Rep1, _Period1>& __lhs,
502 const duration<_Rep2, _Period2>& __rhs)
503 { return !(__lhs == __rhs); }
504
505 template<typename _Rep1, typename _Period1,
506 typename _Rep2, typename _Period2>
507 constexpr bool
508 operator<=(const duration<_Rep1, _Period1>& __lhs,
509 const duration<_Rep2, _Period2>& __rhs)
510 { return !(__rhs < __lhs); }
511
512 template<typename _Rep1, typename _Period1,
513 typename _Rep2, typename _Period2>
514 constexpr bool
515 operator>(const duration<_Rep1, _Period1>& __lhs,
516 const duration<_Rep2, _Period2>& __rhs)
517 { return __rhs < __lhs; }
518
519 template<typename _Rep1, typename _Period1,
520 typename _Rep2, typename _Period2>
521 constexpr bool
522 operator>=(const duration<_Rep1, _Period1>& __lhs,
523 const duration<_Rep2, _Period2>& __rhs)
524 { return !(__lhs < __rhs); }
525
526 /// nanoseconds
527 typedef duration<int64_t, nano> nanoseconds;
528
529 /// microseconds
530 typedef duration<int64_t, micro> microseconds;
531
532 /// milliseconds
533 typedef duration<int64_t, milli> milliseconds;
534
535 /// seconds
536 typedef duration<int64_t> seconds;
537
538 /// minutes
539 typedef duration<int64_t, ratio< 60>> minutes;
540
541 /// hours
542 typedef duration<int64_t, ratio<3600>> hours;
543
544 /// time_point
545 template<typename _Clock, typename _Dur>
546 struct time_point
547 {
548 typedef _Clock clock;
549 typedef _Dur duration;
550 typedef typename duration::rep rep;
551 typedef typename duration::period period;
552
553 constexpr time_point() : __d(duration::zero())
554 { }
555
556 constexpr explicit time_point(const duration& __dur)
557 : __d(__dur)
558 { }
559
560 // conversions
561 template<typename _Dur2>
562 constexpr time_point(const time_point<clock, _Dur2>& __t)
563 : __d(__t.time_since_epoch())
564 { }
565
566 // observer
567 constexpr duration
568 time_since_epoch() const
569 { return __d; }
570
571 // arithmetic
572 time_point&
573 operator+=(const duration& __dur)
574 {
575 __d += __dur;
576 return *this;
577 }
578
579 time_point&
580 operator-=(const duration& __dur)
581 {
582 __d -= __dur;
583 return *this;
584 }
585
586 // special values
587 static constexpr time_point
588 min()
589 { return time_point(duration::min()); }
590
591 static constexpr time_point
592 max()
593 { return time_point(duration::max()); }
594
595 private:
596 duration __d;
597 };
598
599 /// time_point_cast
600 template<typename _ToDur, typename _Clock, typename _Dur>
601 constexpr typename enable_if<__is_duration<_ToDur>::value,
602 time_point<_Clock, _ToDur>>::type
603 time_point_cast(const time_point<_Clock, _Dur>& __t)
604 {
605 typedef time_point<_Clock, _ToDur> __time_point;
606 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
607 }
608
609 template<typename _Clock, typename _Dur1,
610 typename _Rep2, typename _Period2>
611 constexpr time_point<_Clock,
612 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
613 operator+(const time_point<_Clock, _Dur1>& __lhs,
614 const duration<_Rep2, _Period2>& __rhs)
615 {
616 typedef duration<_Rep2, _Period2> __dur2;
617 typedef typename common_type<_Dur1,__dur2>::type __ct;
618 typedef time_point<_Clock, __ct> __time_point;
619 return __time_point(__lhs.time_since_epoch() + __rhs);
620 }
621
622 template<typename _Rep1, typename _Period1,
623 typename _Clock, typename _Dur2>
624 constexpr time_point<_Clock,
625 typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
626 operator+(const duration<_Rep1, _Period1>& __lhs,
627 const time_point<_Clock, _Dur2>& __rhs)
628 {
629 typedef duration<_Rep1, _Period1> __dur1;
630 typedef typename common_type<__dur1,_Dur2>::type __ct;
631 typedef time_point<_Clock, __ct> __time_point;
632 return __time_point(__rhs.time_since_epoch() + __lhs);
633 }
634
635 template<typename _Clock, typename _Dur1,
636 typename _Rep2, typename _Period2>
637 constexpr time_point<_Clock,
638 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
639 operator-(const time_point<_Clock, _Dur1>& __lhs,
640 const duration<_Rep2, _Period2>& __rhs)
641 {
642 typedef duration<_Rep2, _Period2> __dur2;
643 typedef typename common_type<_Dur1,__dur2>::type __ct;
644 typedef time_point<_Clock, __ct> __time_point;
645 return __time_point(__lhs.time_since_epoch() -__rhs);
646 }
647
648 template<typename _Clock, typename _Dur1, typename _Dur2>
649 constexpr typename common_type<_Dur1, _Dur2>::type
650 operator-(const time_point<_Clock, _Dur1>& __lhs,
651 const time_point<_Clock, _Dur2>& __rhs)
652 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
653
654 template<typename _Clock, typename _Dur1, typename _Dur2>
655 constexpr bool
656 operator==(const time_point<_Clock, _Dur1>& __lhs,
657 const time_point<_Clock, _Dur2>& __rhs)
658 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
659
660 template<typename _Clock, typename _Dur1, typename _Dur2>
661 constexpr bool
662 operator!=(const time_point<_Clock, _Dur1>& __lhs,
663 const time_point<_Clock, _Dur2>& __rhs)
664 { return !(__lhs == __rhs); }
665
666 template<typename _Clock, typename _Dur1, typename _Dur2>
667 constexpr bool
668 operator<(const time_point<_Clock, _Dur1>& __lhs,
669 const time_point<_Clock, _Dur2>& __rhs)
670 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
671
672 template<typename _Clock, typename _Dur1, typename _Dur2>
673 constexpr bool
674 operator<=(const time_point<_Clock, _Dur1>& __lhs,
675 const time_point<_Clock, _Dur2>& __rhs)
676 { return !(__rhs < __lhs); }
677
678 template<typename _Clock, typename _Dur1, typename _Dur2>
679 constexpr bool
680 operator>(const time_point<_Clock, _Dur1>& __lhs,
681 const time_point<_Clock, _Dur2>& __rhs)
682 { return __rhs < __lhs; }
683
684 template<typename _Clock, typename _Dur1, typename _Dur2>
685 constexpr bool
686 operator>=(const time_point<_Clock, _Dur1>& __lhs,
687 const time_point<_Clock, _Dur2>& __rhs)
688 { return !(__lhs < __rhs); }
689
690
691 // Clocks.
692
693 // Why nanosecond resolution as the default?
694 // Why have std::system_clock always count in the higest
695 // resolution (ie nanoseconds), even if on some OSes the low 3
696 // or 9 decimal digits will be always zero? This allows later
697 // implementations to change the system_clock::now()
698 // implementation any time to provide better resolution without
699 // changing function signature or units.
700
701 // To support the (forward) evolution of the library's defined
702 // clocks, wrap inside inline namespace so that the current
703 // defintions of system_clock, steady_clock, and
704 // high_resolution_clock types are uniquely mangled. This way, new
705 // code can use the latests clocks, while the library can contain
706 // compatibility definitions for previous versions. At some
707 // point, when these clocks settle down, the inlined namespaces
708 // can be removed. XXX GLIBCXX_ABI Deprecated
709 inline namespace _V2 {
710
711 /**
712 * @brief System clock.
713 *
714 * Time returned represents wall time from the system-wide clock.
715 */
716 struct system_clock
717 {
718 typedef chrono::nanoseconds duration;
719 typedef duration::rep rep;
720 typedef duration::period period;
721 typedef chrono::time_point<system_clock, duration> time_point;
722
723 static_assert(system_clock::duration::min()
724 < system_clock::duration::zero(),
725 "a clock's minimum duration cannot be less than its epoch");
726
727 static constexpr bool is_steady = false;
728
729 static time_point
730 now() noexcept;
731
732 // Map to C API
733 static std::time_t
734 to_time_t(const time_point& __t) noexcept
735 {
736 return std::time_t(duration_cast<chrono::seconds>
737 (__t.time_since_epoch()).count());
738 }
739
740 static time_point
741 from_time_t(std::time_t __t) noexcept
742 {
743 typedef chrono::time_point<system_clock, seconds> __from;
744 return time_point_cast<system_clock::duration>
745 (__from(chrono::seconds(__t)));
746 }
747 };
748
749
750 /**
751 * @brief Monotonic clock
752 *
753 * Time returned has the property of only increasing at a uniform rate.
754 */
755 struct steady_clock
756 {
757 typedef chrono::nanoseconds duration;
758 typedef duration::rep rep;
759 typedef duration::period period;
760 typedef chrono::time_point<steady_clock, duration> time_point;
761
762 static constexpr bool is_steady = true;
763
764 static time_point
765 now() noexcept;
766 };
767
768
769 /**
770 * @brief Highest-resolution clock
771 *
772 * This is the clock "with the shortest tick period." Alias to
773 * std::system_clock until higher-than-nanosecond definitions
774 * become feasible.
775 */
776 using high_resolution_clock = system_clock;
777
778 } // end inline namespace _V2
779
780 _GLIBCXX_END_NAMESPACE_VERSION
781 } // namespace chrono
782
783#if __cplusplus > 201103L
784
785#define __cpp_lib_chrono_udls 201304
786
787 inline namespace literals
788 {
789 inline namespace chrono_literals
790 {
791
792 template<typename _Rep, unsigned long long _Val>
793 struct _Checked_integral_constant
794 : integral_constant<_Rep, static_cast<_Rep>(_Val)>
795 {
796 static_assert(_Checked_integral_constant::value >= 0
797 && _Checked_integral_constant::value == _Val,
798 "literal value cannot be represented by duration type");
799 };
800
801 template<typename _Dur, char... _Digits>
802 constexpr _Dur __check_overflow()
803 {
804 using _Val = __parse_int::_Parse_int<_Digits...>;
805 using _Rep = typename _Dur::rep;
806 // TODO: should be simply integral_constant<_Rep, _Val::value>
807 // but GCC doesn't reject narrowing conversions to _Rep.
808 using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>;
809 return _Dur{_CheckedVal::value};
810 }
811
812 constexpr chrono::duration<long double, ratio<3600,1>>
813 operator""h(long double __hours)
814 { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
815
816 template <char... _Digits>
817 constexpr chrono::hours
818 operator""h()
819 { return __check_overflow<chrono::hours, _Digits...>(); }
820
821 constexpr chrono::duration<long double, ratio<60,1>>
822 operator""min(long double __mins)
823 { return chrono::duration<long double, ratio<60,1>>{__mins}; }
824
825 template <char... _Digits>
826 constexpr chrono::minutes
827 operator""min()
828 { return __check_overflow<chrono::minutes, _Digits...>(); }
829
830 constexpr chrono::duration<long double>
831 operator""s(long double __secs)
832 { return chrono::duration<long double>{__secs}; }
833
834 template <char... _Digits>
835 constexpr chrono::seconds
836 operator""s()
837 { return __check_overflow<chrono::seconds, _Digits...>(); }
838
839 constexpr chrono::duration<long double, milli>
840 operator""ms(long double __msecs)
841 { return chrono::duration<long double, milli>{__msecs}; }
842
843 template <char... _Digits>
844 constexpr chrono::milliseconds
845 operator""ms()
846 { return __check_overflow<chrono::milliseconds, _Digits...>(); }
847
848 constexpr chrono::duration<long double, micro>
849 operator""us(long double __usecs)
850 { return chrono::duration<long double, micro>{__usecs}; }
851
852 template <char... _Digits>
853 constexpr chrono::microseconds
854 operator""us()
855 { return __check_overflow<chrono::microseconds, _Digits...>(); }
856
857 constexpr chrono::duration<long double, nano>
858 operator""ns(long double __nsecs)
859 { return chrono::duration<long double, nano>{__nsecs}; }
860
861 template <char... _Digits>
862 constexpr chrono::nanoseconds
863 operator""ns()
864 { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
865
866 } // inline namespace chrono_literals
867 } // inline namespace literals
868
869 namespace chrono
870 {
871 _GLIBCXX_BEGIN_NAMESPACE_VERSION
872
873 using namespace literals::chrono_literals;
874
875 _GLIBCXX_END_NAMESPACE_VERSION
876 } // namespace chrono
877
878#endif // __cplusplus > 201103L
879
880 // @} group chrono
881} // namespace std
882
883#endif //_GLIBCXX_USE_C99_STDINT_TR1
884
885#endif // C++11
886
887#endif //_GLIBCXX_CHRONO
888