libstdc++
chrono
Go to the documentation of this file.
1// <chrono> -*- C++ -*-
2
3// Copyright (C) 2008-2016 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 // _GLIBCXX_RESOLVE_LIB_DEFECTS
260 // 3050. Conversion specification problem in chrono::duration
261 template<typename _Rep2, typename = typename
262 enable_if<is_convertible<const _Rep2&, rep>::value
263 && (treat_as_floating_point<rep>::value
264 || !treat_as_floating_point<_Rep2>::value)>::type>
265 constexpr explicit duration(const _Rep2& __rep)
266 : __r(static_cast<rep>(__rep)) { }
267
268 template<typename _Rep2, typename _Period2, typename = typename
269 enable_if<treat_as_floating_point<rep>::value
270 || (ratio_divide<_Period2, period>::den == 1
271 && !treat_as_floating_point<_Rep2>::value)>::type>
272 constexpr duration(const duration<_Rep2, _Period2>& __d)
273 : __r(duration_cast<duration>(__d).count()) { }
274
275 ~duration() = default;
276 duration& operator=(const duration&) = default;
277
278 // 20.11.5.2 observer
279 constexpr rep
280 count() const
281 { return __r; }
282
283 // 20.11.5.3 arithmetic
284 constexpr duration
285 operator+() const
286 { return *this; }
287
288 constexpr duration
289 operator-() const
290 { return duration(-__r); }
291
292 duration&
293 operator++()
294 {
295 ++__r;
296 return *this;
297 }
298
299 duration
300 operator++(int)
301 { return duration(__r++); }
302
303 duration&
304 operator--()
305 {
306 --__r;
307 return *this;
308 }
309
310 duration
311 operator--(int)
312 { return duration(__r--); }
313
314 duration&
315 operator+=(const duration& __d)
316 {
317 __r += __d.count();
318 return *this;
319 }
320
321 duration&
322 operator-=(const duration& __d)
323 {
324 __r -= __d.count();
325 return *this;
326 }
327
328 duration&
329 operator*=(const rep& __rhs)
330 {
331 __r *= __rhs;
332 return *this;
333 }
334
335 duration&
336 operator/=(const rep& __rhs)
337 {
338 __r /= __rhs;
339 return *this;
340 }
341
342 // DR 934.
343 template<typename _Rep2 = rep>
344 typename enable_if<!treat_as_floating_point<_Rep2>::value,
345 duration&>::type
346 operator%=(const rep& __rhs)
347 {
348 __r %= __rhs;
349 return *this;
350 }
351
352 template<typename _Rep2 = rep>
353 typename enable_if<!treat_as_floating_point<_Rep2>::value,
354 duration&>::type
355 operator%=(const duration& __d)
356 {
357 __r %= __d.count();
358 return *this;
359 }
360
361 // 20.11.5.4 special values
362 static constexpr duration
363 zero()
364 { return duration(duration_values<rep>::zero()); }
365
366 static constexpr duration
367 min()
368 { return duration(duration_values<rep>::min()); }
369
370 static constexpr duration
371 max()
372 { return duration(duration_values<rep>::max()); }
373
374 private:
375 rep __r;
376 };
377
378 template<typename _Rep1, typename _Period1,
379 typename _Rep2, typename _Period2>
380 constexpr typename common_type<duration<_Rep1, _Period1>,
381 duration<_Rep2, _Period2>>::type
382 operator+(const duration<_Rep1, _Period1>& __lhs,
383 const duration<_Rep2, _Period2>& __rhs)
384 {
385 typedef duration<_Rep1, _Period1> __dur1;
386 typedef duration<_Rep2, _Period2> __dur2;
387 typedef typename common_type<__dur1,__dur2>::type __cd;
388 return __cd(__cd(__lhs).count() + __cd(__rhs).count());
389 }
390
391 template<typename _Rep1, typename _Period1,
392 typename _Rep2, typename _Period2>
393 constexpr typename common_type<duration<_Rep1, _Period1>,
394 duration<_Rep2, _Period2>>::type
395 operator-(const duration<_Rep1, _Period1>& __lhs,
396 const duration<_Rep2, _Period2>& __rhs)
397 {
398 typedef duration<_Rep1, _Period1> __dur1;
399 typedef duration<_Rep2, _Period2> __dur2;
400 typedef typename common_type<__dur1,__dur2>::type __cd;
401 return __cd(__cd(__lhs).count() - __cd(__rhs).count());
402 }
403
404 // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2
405 // is implicitly convertible to it.
406 // _GLIBCXX_RESOLVE_LIB_DEFECTS
407 // 3050. Conversion specification problem in chrono::duration constructor
408 template<typename _Rep1, typename _Rep2, bool =
409 is_convertible<const _Rep2&,
410 typename common_type<_Rep1, _Rep2>::type>::value>
411 struct __common_rep_type { };
412
413 template<typename _Rep1, typename _Rep2>
414 struct __common_rep_type<_Rep1, _Rep2, true>
415 { typedef typename common_type<_Rep1, _Rep2>::type type; };
416
417 template<typename _Rep1, typename _Period, typename _Rep2>
418 constexpr
419 duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
420 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
421 {
422 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
423 __cd;
424 return __cd(__cd(__d).count() * __s);
425 }
426
427 template<typename _Rep1, typename _Rep2, typename _Period>
428 constexpr
429 duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
430 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
431 { return __d * __s; }
432
433 template<typename _Rep1, typename _Period, typename _Rep2>
434 constexpr duration<typename __common_rep_type<_Rep1, typename
435 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
436 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
437 {
438 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
439 __cd;
440 return __cd(__cd(__d).count() / __s);
441 }
442
443 template<typename _Rep1, typename _Period1,
444 typename _Rep2, typename _Period2>
445 constexpr typename common_type<_Rep1, _Rep2>::type
446 operator/(const duration<_Rep1, _Period1>& __lhs,
447 const duration<_Rep2, _Period2>& __rhs)
448 {
449 typedef duration<_Rep1, _Period1> __dur1;
450 typedef duration<_Rep2, _Period2> __dur2;
451 typedef typename common_type<__dur1,__dur2>::type __cd;
452 return __cd(__lhs).count() / __cd(__rhs).count();
453 }
454
455 // DR 934.
456 template<typename _Rep1, typename _Period, typename _Rep2>
457 constexpr duration<typename __common_rep_type<_Rep1, typename
458 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
459 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
460 {
461 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
462 __cd;
463 return __cd(__cd(__d).count() % __s);
464 }
465
466 template<typename _Rep1, typename _Period1,
467 typename _Rep2, typename _Period2>
468 constexpr typename common_type<duration<_Rep1, _Period1>,
469 duration<_Rep2, _Period2>>::type
470 operator%(const duration<_Rep1, _Period1>& __lhs,
471 const duration<_Rep2, _Period2>& __rhs)
472 {
473 typedef duration<_Rep1, _Period1> __dur1;
474 typedef duration<_Rep2, _Period2> __dur2;
475 typedef typename common_type<__dur1,__dur2>::type __cd;
476 return __cd(__cd(__lhs).count() % __cd(__rhs).count());
477 }
478
479 // comparisons
480 template<typename _Rep1, typename _Period1,
481 typename _Rep2, typename _Period2>
482 constexpr bool
483 operator==(const duration<_Rep1, _Period1>& __lhs,
484 const duration<_Rep2, _Period2>& __rhs)
485 {
486 typedef duration<_Rep1, _Period1> __dur1;
487 typedef duration<_Rep2, _Period2> __dur2;
488 typedef typename common_type<__dur1,__dur2>::type __ct;
489 return __ct(__lhs).count() == __ct(__rhs).count();
490 }
491
492 template<typename _Rep1, typename _Period1,
493 typename _Rep2, typename _Period2>
494 constexpr bool
495 operator<(const duration<_Rep1, _Period1>& __lhs,
496 const duration<_Rep2, _Period2>& __rhs)
497 {
498 typedef duration<_Rep1, _Period1> __dur1;
499 typedef duration<_Rep2, _Period2> __dur2;
500 typedef typename common_type<__dur1,__dur2>::type __ct;
501 return __ct(__lhs).count() < __ct(__rhs).count();
502 }
503
504 template<typename _Rep1, typename _Period1,
505 typename _Rep2, typename _Period2>
506 constexpr bool
507 operator!=(const duration<_Rep1, _Period1>& __lhs,
508 const duration<_Rep2, _Period2>& __rhs)
509 { return !(__lhs == __rhs); }
510
511 template<typename _Rep1, typename _Period1,
512 typename _Rep2, typename _Period2>
513 constexpr bool
514 operator<=(const duration<_Rep1, _Period1>& __lhs,
515 const duration<_Rep2, _Period2>& __rhs)
516 { return !(__rhs < __lhs); }
517
518 template<typename _Rep1, typename _Period1,
519 typename _Rep2, typename _Period2>
520 constexpr bool
521 operator>(const duration<_Rep1, _Period1>& __lhs,
522 const duration<_Rep2, _Period2>& __rhs)
523 { return __rhs < __lhs; }
524
525 template<typename _Rep1, typename _Period1,
526 typename _Rep2, typename _Period2>
527 constexpr bool
528 operator>=(const duration<_Rep1, _Period1>& __lhs,
529 const duration<_Rep2, _Period2>& __rhs)
530 { return !(__lhs < __rhs); }
531
532 /// nanoseconds
533 typedef duration<int64_t, nano> nanoseconds;
534
535 /// microseconds
536 typedef duration<int64_t, micro> microseconds;
537
538 /// milliseconds
539 typedef duration<int64_t, milli> milliseconds;
540
541 /// seconds
542 typedef duration<int64_t> seconds;
543
544 /// minutes
545 typedef duration<int64_t, ratio< 60>> minutes;
546
547 /// hours
548 typedef duration<int64_t, ratio<3600>> hours;
549
550 /// time_point
551 template<typename _Clock, typename _Dur>
552 struct time_point
553 {
554 typedef _Clock clock;
555 typedef _Dur duration;
556 typedef typename duration::rep rep;
557 typedef typename duration::period period;
558
559 constexpr time_point() : __d(duration::zero())
560 { }
561
562 constexpr explicit time_point(const duration& __dur)
563 : __d(__dur)
564 { }
565
566 // conversions
567 template<typename _Dur2,
568 typename = _Require<is_convertible<_Dur2, _Dur>>>
569 constexpr time_point(const time_point<clock, _Dur2>& __t)
570 : __d(__t.time_since_epoch())
571 { }
572
573 // observer
574 constexpr duration
575 time_since_epoch() const
576 { return __d; }
577
578 // arithmetic
579 time_point&
580 operator+=(const duration& __dur)
581 {
582 __d += __dur;
583 return *this;
584 }
585
586 time_point&
587 operator-=(const duration& __dur)
588 {
589 __d -= __dur;
590 return *this;
591 }
592
593 // special values
594 static constexpr time_point
595 min()
596 { return time_point(duration::min()); }
597
598 static constexpr time_point
599 max()
600 { return time_point(duration::max()); }
601
602 private:
603 duration __d;
604 };
605
606 /// time_point_cast
607 template<typename _ToDur, typename _Clock, typename _Dur>
608 constexpr typename enable_if<__is_duration<_ToDur>::value,
609 time_point<_Clock, _ToDur>>::type
610 time_point_cast(const time_point<_Clock, _Dur>& __t)
611 {
612 typedef time_point<_Clock, _ToDur> __time_point;
613 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
614 }
615
616 template<typename _Clock, typename _Dur1,
617 typename _Rep2, typename _Period2>
618 constexpr time_point<_Clock,
619 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
620 operator+(const time_point<_Clock, _Dur1>& __lhs,
621 const duration<_Rep2, _Period2>& __rhs)
622 {
623 typedef duration<_Rep2, _Period2> __dur2;
624 typedef typename common_type<_Dur1,__dur2>::type __ct;
625 typedef time_point<_Clock, __ct> __time_point;
626 return __time_point(__lhs.time_since_epoch() + __rhs);
627 }
628
629 template<typename _Rep1, typename _Period1,
630 typename _Clock, typename _Dur2>
631 constexpr time_point<_Clock,
632 typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
633 operator+(const duration<_Rep1, _Period1>& __lhs,
634 const time_point<_Clock, _Dur2>& __rhs)
635 {
636 typedef duration<_Rep1, _Period1> __dur1;
637 typedef typename common_type<__dur1,_Dur2>::type __ct;
638 typedef time_point<_Clock, __ct> __time_point;
639 return __time_point(__rhs.time_since_epoch() + __lhs);
640 }
641
642 template<typename _Clock, typename _Dur1,
643 typename _Rep2, typename _Period2>
644 constexpr time_point<_Clock,
645 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
646 operator-(const time_point<_Clock, _Dur1>& __lhs,
647 const duration<_Rep2, _Period2>& __rhs)
648 {
649 typedef duration<_Rep2, _Period2> __dur2;
650 typedef typename common_type<_Dur1,__dur2>::type __ct;
651 typedef time_point<_Clock, __ct> __time_point;
652 return __time_point(__lhs.time_since_epoch() -__rhs);
653 }
654
655 template<typename _Clock, typename _Dur1, typename _Dur2>
656 constexpr typename common_type<_Dur1, _Dur2>::type
657 operator-(const time_point<_Clock, _Dur1>& __lhs,
658 const time_point<_Clock, _Dur2>& __rhs)
659 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
660
661 template<typename _Clock, typename _Dur1, typename _Dur2>
662 constexpr bool
663 operator==(const time_point<_Clock, _Dur1>& __lhs,
664 const time_point<_Clock, _Dur2>& __rhs)
665 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
666
667 template<typename _Clock, typename _Dur1, typename _Dur2>
668 constexpr bool
669 operator!=(const time_point<_Clock, _Dur1>& __lhs,
670 const time_point<_Clock, _Dur2>& __rhs)
671 { return !(__lhs == __rhs); }
672
673 template<typename _Clock, typename _Dur1, typename _Dur2>
674 constexpr bool
675 operator<(const time_point<_Clock, _Dur1>& __lhs,
676 const time_point<_Clock, _Dur2>& __rhs)
677 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
678
679 template<typename _Clock, typename _Dur1, typename _Dur2>
680 constexpr bool
681 operator<=(const time_point<_Clock, _Dur1>& __lhs,
682 const time_point<_Clock, _Dur2>& __rhs)
683 { return !(__rhs < __lhs); }
684
685 template<typename _Clock, typename _Dur1, typename _Dur2>
686 constexpr bool
687 operator>(const time_point<_Clock, _Dur1>& __lhs,
688 const time_point<_Clock, _Dur2>& __rhs)
689 { return __rhs < __lhs; }
690
691 template<typename _Clock, typename _Dur1, typename _Dur2>
692 constexpr bool
693 operator>=(const time_point<_Clock, _Dur1>& __lhs,
694 const time_point<_Clock, _Dur2>& __rhs)
695 { return !(__lhs < __rhs); }
696
697
698 // Clocks.
699
700 // Why nanosecond resolution as the default?
701 // Why have std::system_clock always count in the higest
702 // resolution (ie nanoseconds), even if on some OSes the low 3
703 // or 9 decimal digits will be always zero? This allows later
704 // implementations to change the system_clock::now()
705 // implementation any time to provide better resolution without
706 // changing function signature or units.
707
708 // To support the (forward) evolution of the library's defined
709 // clocks, wrap inside inline namespace so that the current
710 // defintions of system_clock, steady_clock, and
711 // high_resolution_clock types are uniquely mangled. This way, new
712 // code can use the latests clocks, while the library can contain
713 // compatibility definitions for previous versions. At some
714 // point, when these clocks settle down, the inlined namespaces
715 // can be removed. XXX GLIBCXX_ABI Deprecated
716 inline namespace _V2 {
717
718 /**
719 * @brief System clock.
720 *
721 * Time returned represents wall time from the system-wide clock.
722 */
723 struct system_clock
724 {
725 typedef chrono::nanoseconds duration;
726 typedef duration::rep rep;
727 typedef duration::period period;
728 typedef chrono::time_point<system_clock, duration> time_point;
729
730 static_assert(system_clock::duration::min()
731 < system_clock::duration::zero(),
732 "a clock's minimum duration cannot be less than its epoch");
733
734 static constexpr bool is_steady = false;
735
736 static time_point
737 now() noexcept;
738
739 // Map to C API
740 static std::time_t
741 to_time_t(const time_point& __t) noexcept
742 {
743 return std::time_t(duration_cast<chrono::seconds>
744 (__t.time_since_epoch()).count());
745 }
746
747 static time_point
748 from_time_t(std::time_t __t) noexcept
749 {
750 typedef chrono::time_point<system_clock, seconds> __from;
751 return time_point_cast<system_clock::duration>
752 (__from(chrono::seconds(__t)));
753 }
754 };
755
756
757 /**
758 * @brief Monotonic clock
759 *
760 * Time returned has the property of only increasing at a uniform rate.
761 */
762 struct steady_clock
763 {
764 typedef chrono::nanoseconds duration;
765 typedef duration::rep rep;
766 typedef duration::period period;
767 typedef chrono::time_point<steady_clock, duration> time_point;
768
769 static constexpr bool is_steady = true;
770
771 static time_point
772 now() noexcept;
773 };
774
775
776 /**
777 * @brief Highest-resolution clock
778 *
779 * This is the clock "with the shortest tick period." Alias to
780 * std::system_clock until higher-than-nanosecond definitions
781 * become feasible.
782 */
783 using high_resolution_clock = system_clock;
784
785 } // end inline namespace _V2
786
787 _GLIBCXX_END_NAMESPACE_VERSION
788 } // namespace chrono
789
790#if __cplusplus > 201103L
791
792#define __cpp_lib_chrono_udls 201304
793
794 inline namespace literals
795 {
796 inline namespace chrono_literals
797 {
798 _GLIBCXX_BEGIN_NAMESPACE_VERSION
799
800 template<typename _Rep, unsigned long long _Val>
801 struct _Checked_integral_constant
802 : integral_constant<_Rep, static_cast<_Rep>(_Val)>
803 {
804 static_assert(_Checked_integral_constant::value >= 0
805 && _Checked_integral_constant::value == _Val,
806 "literal value cannot be represented by duration type");
807 };
808
809 template<typename _Dur, char... _Digits>
810 constexpr _Dur __check_overflow()
811 {
812 using _Val = __parse_int::_Parse_int<_Digits...>;
813 using _Rep = typename _Dur::rep;
814 // TODO: should be simply integral_constant<_Rep, _Val::value>
815 // but GCC doesn't reject narrowing conversions to _Rep.
816 using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>;
817 return _Dur{_CheckedVal::value};
818 }
819
820 constexpr chrono::duration<long double, ratio<3600,1>>
821 operator""h(long double __hours)
822 { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
823
824 template <char... _Digits>
825 constexpr chrono::hours
826 operator""h()
827 { return __check_overflow<chrono::hours, _Digits...>(); }
828
829 constexpr chrono::duration<long double, ratio<60,1>>
830 operator""min(long double __mins)
831 { return chrono::duration<long double, ratio<60,1>>{__mins}; }
832
833 template <char... _Digits>
834 constexpr chrono::minutes
835 operator""min()
836 { return __check_overflow<chrono::minutes, _Digits...>(); }
837
838 constexpr chrono::duration<long double>
839 operator""s(long double __secs)
840 { return chrono::duration<long double>{__secs}; }
841
842 template <char... _Digits>
843 constexpr chrono::seconds
844 operator""s()
845 { return __check_overflow<chrono::seconds, _Digits...>(); }
846
847 constexpr chrono::duration<long double, milli>
848 operator""ms(long double __msecs)
849 { return chrono::duration<long double, milli>{__msecs}; }
850
851 template <char... _Digits>
852 constexpr chrono::milliseconds
853 operator""ms()
854 { return __check_overflow<chrono::milliseconds, _Digits...>(); }
855
856 constexpr chrono::duration<long double, micro>
857 operator""us(long double __usecs)
858 { return chrono::duration<long double, micro>{__usecs}; }
859
860 template <char... _Digits>
861 constexpr chrono::microseconds
862 operator""us()
863 { return __check_overflow<chrono::microseconds, _Digits...>(); }
864
865 constexpr chrono::duration<long double, nano>
866 operator""ns(long double __nsecs)
867 { return chrono::duration<long double, nano>{__nsecs}; }
868
869 template <char... _Digits>
870 constexpr chrono::nanoseconds
871 operator""ns()
872 { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
873
874 _GLIBCXX_END_NAMESPACE_VERSION
875 } // inline namespace chrono_literals
876 } // inline namespace literals
877
878 namespace chrono
879 {
880 _GLIBCXX_BEGIN_NAMESPACE_VERSION
881
882 using namespace literals::chrono_literals;
883
884 _GLIBCXX_END_NAMESPACE_VERSION
885 } // namespace chrono
886
887#endif // __cplusplus > 201103L
888
889 // @} group chrono
890} // namespace std
891
892#endif //_GLIBCXX_USE_C99_STDINT_TR1
893
894#endif // C++11
895
896#endif //_GLIBCXX_CHRONO