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