1// <chrono> -*- C++ -*- 2 3// Copyright (C) 2008-2018 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_GLIBCXX_BEGIN_NAMESPACE_VERSION 49 50 /** 51 * @defgroup chrono Time 52 * @ingroup utilities 53 * 54 * Classes and functions for time. 55 * @{ 56 */ 57 58 /** @namespace std::chrono 59 * @brief ISO C++ 2011 entities sub-namespace for time and date. 60 */ 61 namespace chrono 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 70 // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) 71 72 template<typename _CT, typename _Period1, typename _Period2> 73 struct __duration_common_type_wrapper 74 { 75 private: 76 typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num; 77 typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den; 78 typedef typename _CT::type __cr; 79 typedef ratio<__gcd_num::value, 80 (_Period1::den / __gcd_den::value) * _Period2::den> __r; 81 public: 82 typedef __success_type<chrono::duration<__cr, __r>> type; 83 }; 84 85 template<typename _Period1, typename _Period2> 86 struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2> 87 { typedef __failure_type type; }; 88 89 template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> 90 struct common_type<chrono::duration<_Rep1, _Period1>, 91 chrono::duration<_Rep2, _Period2>> 92 : public __duration_common_type_wrapper<typename __member_type_wrapper< 93 common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type 94 { }; 95 96 // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) 97 98 template<typename _CT, typename _Clock> 99 struct __timepoint_common_type_wrapper 100 { 101 typedef __success_type<chrono::time_point<_Clock, typename _CT::type>> 102 type; 103 }; 104 105 template<typename _Clock> 106 struct __timepoint_common_type_wrapper<__failure_type, _Clock> 107 { typedef __failure_type type; }; 108 109 template<typename _Clock, typename _Duration1, typename _Duration2> 110 struct common_type<chrono::time_point<_Clock, _Duration1>, 111 chrono::time_point<_Clock, _Duration2>> 112 : public __timepoint_common_type_wrapper<typename __member_type_wrapper< 113 common_type<_Duration1, _Duration2>>::type, _Clock>::type 114 { }; 115 116 namespace chrono 117 { 118 // Primary template for duration_cast impl. 119 template<typename _ToDur, typename _CF, typename _CR, 120 bool _NumIsOne = false, bool _DenIsOne = false> 121 struct __duration_cast_impl 122 { 123 template<typename _Rep, typename _Period> 124 static constexpr _ToDur 125 __cast(const duration<_Rep, _Period>& __d) 126 { 127 typedef typename _ToDur::rep __to_rep; 128 return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) 129 * static_cast<_CR>(_CF::num) 130 / static_cast<_CR>(_CF::den))); 131 } 132 }; 133 134 template<typename _ToDur, typename _CF, typename _CR> 135 struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> 136 { 137 template<typename _Rep, typename _Period> 138 static constexpr _ToDur 139 __cast(const duration<_Rep, _Period>& __d) 140 { 141 typedef typename _ToDur::rep __to_rep; 142 return _ToDur(static_cast<__to_rep>(__d.count())); 143 } 144 }; 145 146 template<typename _ToDur, typename _CF, typename _CR> 147 struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> 148 { 149 template<typename _Rep, typename _Period> 150 static constexpr _ToDur 151 __cast(const duration<_Rep, _Period>& __d) 152 { 153 typedef typename _ToDur::rep __to_rep; 154 return _ToDur(static_cast<__to_rep>( 155 static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 156 } 157 }; 158 159 template<typename _ToDur, typename _CF, typename _CR> 160 struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> 161 { 162 template<typename _Rep, typename _Period> 163 static constexpr _ToDur 164 __cast(const duration<_Rep, _Period>& __d) 165 { 166 typedef typename _ToDur::rep __to_rep; 167 return _ToDur(static_cast<__to_rep>( 168 static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); 169 } 170 }; 171 172 template<typename _Tp> 173 struct __is_duration 174 : std::false_type 175 { }; 176 177 template<typename _Rep, typename _Period> 178 struct __is_duration<duration<_Rep, _Period>> 179 : std::true_type 180 { }; 181 182 template<typename _Tp> 183 using __enable_if_is_duration 184 = typename enable_if<__is_duration<_Tp>::value, _Tp>::type; 185 186 template<typename _Tp> 187 using __disable_if_is_duration 188 = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type; 189 190 /// duration_cast 191 template<typename _ToDur, typename _Rep, typename _Period> 192 constexpr __enable_if_is_duration<_ToDur> 193 duration_cast(const duration<_Rep, _Period>& __d) 194 { 195 typedef typename _ToDur::period __to_period; 196 typedef typename _ToDur::rep __to_rep; 197 typedef ratio_divide<_Period, __to_period> __cf; 198 typedef typename common_type<__to_rep, _Rep, intmax_t>::type 199 __cr; 200 typedef __duration_cast_impl<_ToDur, __cf, __cr, 201 __cf::num == 1, __cf::den == 1> __dc; 202 return __dc::__cast(__d); 203 } 204 205 /// treat_as_floating_point 206 template<typename _Rep> 207 struct treat_as_floating_point 208 : is_floating_point<_Rep> 209 { }; 210 211#if __cplusplus > 201402L 212 template <typename _Rep> 213 inline constexpr bool treat_as_floating_point_v = 214 treat_as_floating_point<_Rep>::value; 215#endif // C++17 216 217#if __cplusplus >= 201703L 218# define __cpp_lib_chrono 201611 219 220 template<typename _ToDur, typename _Rep, typename _Period> 221 constexpr __enable_if_is_duration<_ToDur> 222 floor(const duration<_Rep, _Period>& __d) 223 { 224 auto __to = chrono::duration_cast<_ToDur>(__d); 225 if (__to > __d) 226 return __to - _ToDur{1}; 227 return __to; 228 } 229 230 template<typename _ToDur, typename _Rep, typename _Period> 231 constexpr __enable_if_is_duration<_ToDur> 232 ceil(const duration<_Rep, _Period>& __d) 233 { 234 auto __to = chrono::duration_cast<_ToDur>(__d); 235 if (__to < __d) 236 return __to + _ToDur{1}; 237 return __to; 238 } 239 240 template <typename _ToDur, typename _Rep, typename _Period> 241 constexpr enable_if_t< 242 __and_<__is_duration<_ToDur>, 243 __not_<treat_as_floating_point<typename _ToDur::rep>>>::value, 244 _ToDur> 245 round(const duration<_Rep, _Period>& __d) 246 { 247 _ToDur __t0 = chrono::floor<_ToDur>(__d); 248 _ToDur __t1 = __t0 + _ToDur{1}; 249 auto __diff0 = __d - __t0; 250 auto __diff1 = __t1 - __d; 251 if (__diff0 == __diff1) 252 { 253 if (__t0.count() & 1) 254 return __t1; 255 return __t0; 256 } 257 else if (__diff0 < __diff1) 258 return __t0; 259 return __t1; 260 } 261 262 template<typename _Rep, typename _Period> 263 constexpr 264 enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>> 265 abs(duration<_Rep, _Period> __d) 266 { 267 if (__d >= __d.zero()) 268 return __d; 269 return -__d; 270 } 271#endif // C++17 272 273 /// duration_values 274 template<typename _Rep> 275 struct duration_values 276 { 277 static constexpr _Rep 278 zero() noexcept 279 { return _Rep(0); } 280 281 static constexpr _Rep 282 max() noexcept 283 { return numeric_limits<_Rep>::max(); } 284 285 static constexpr _Rep 286 min() noexcept 287 { return numeric_limits<_Rep>::lowest(); } 288 }; 289 290 template<typename _Tp> 291 struct __is_ratio 292 : std::false_type 293 { }; 294 295 template<intmax_t _Num, intmax_t _Den> 296 struct __is_ratio<ratio<_Num, _Den>> 297 : std::true_type 298 { }; 299 300 /// duration 301 template<typename _Rep, typename _Period> 302 struct duration 303 { 304 private: 305 template<typename _Rep2> 306 using __is_float = treat_as_floating_point<_Rep2>; 307 308 // _Period2 is an exact multiple of _Period 309 template<typename _Period2> 310 using __is_harmonic 311 = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>; 312 313 public: 314 315 typedef _Rep rep; 316 typedef _Period period; 317 318 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); 319 static_assert(__is_ratio<_Period>::value, 320 "period must be a specialization of ratio"); 321 static_assert(_Period::num > 0, "period must be positive"); 322 323 // 20.11.5.1 construction / copy / destroy 324 constexpr duration() = default; 325 326 duration(const duration&) = default; 327 328 // _GLIBCXX_RESOLVE_LIB_DEFECTS 329 // 3050. Conversion specification problem in chrono::duration 330 template<typename _Rep2, typename = _Require< 331 is_convertible<const _Rep2&, rep>, 332 __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>> 333 constexpr explicit duration(const _Rep2& __rep) 334 : __r(static_cast<rep>(__rep)) { } 335 336 template<typename _Rep2, typename _Period2, typename = _Require< 337 __or_<__is_float<rep>, 338 __and_<__is_harmonic<_Period2>, 339 __not_<__is_float<_Rep2>>>>>> 340 constexpr duration(const duration<_Rep2, _Period2>& __d) 341 : __r(duration_cast<duration>(__d).count()) { } 342 343 ~duration() = default; 344 duration& operator=(const duration&) = default; 345 346 // 20.11.5.2 observer 347 constexpr rep 348 count() const 349 { return __r; } 350 351 // 20.11.5.3 arithmetic 352 constexpr duration 353 operator+() const 354 { return *this; } 355 356 constexpr duration 357 operator-() const 358 { return duration(-__r); } 359 360 _GLIBCXX17_CONSTEXPR duration& 361 operator++() 362 { 363 ++__r; 364 return *this; 365 } 366 367 _GLIBCXX17_CONSTEXPR duration 368 operator++(int) 369 { return duration(__r++); } 370 371 _GLIBCXX17_CONSTEXPR duration& 372 operator--() 373 { 374 --__r; 375 return *this; 376 } 377 378 _GLIBCXX17_CONSTEXPR duration 379 operator--(int) 380 { return duration(__r--); } 381 382 _GLIBCXX17_CONSTEXPR duration& 383 operator+=(const duration& __d) 384 { 385 __r += __d.count(); 386 return *this; 387 } 388 389 _GLIBCXX17_CONSTEXPR duration& 390 operator-=(const duration& __d) 391 { 392 __r -= __d.count(); 393 return *this; 394 } 395 396 _GLIBCXX17_CONSTEXPR duration& 397 operator*=(const rep& __rhs) 398 { 399 __r *= __rhs; 400 return *this; 401 } 402 403 _GLIBCXX17_CONSTEXPR duration& 404 operator/=(const rep& __rhs) 405 { 406 __r /= __rhs; 407 return *this; 408 } 409 410 // DR 934. 411 template<typename _Rep2 = rep> 412 _GLIBCXX17_CONSTEXPR 413 typename enable_if<!treat_as_floating_point<_Rep2>::value, 414 duration&>::type 415 operator%=(const rep& __rhs) 416 { 417 __r %= __rhs; 418 return *this; 419 } 420 421 template<typename _Rep2 = rep> 422 _GLIBCXX17_CONSTEXPR 423 typename enable_if<!treat_as_floating_point<_Rep2>::value, 424 duration&>::type 425 operator%=(const duration& __d) 426 { 427 __r %= __d.count(); 428 return *this; 429 } 430 431 // 20.11.5.4 special values 432 static constexpr duration 433 zero() noexcept 434 { return duration(duration_values<rep>::zero()); } 435 436 static constexpr duration 437 min() noexcept 438 { return duration(duration_values<rep>::min()); } 439 440 static constexpr duration 441 max() noexcept 442 { return duration(duration_values<rep>::max()); } 443 444 private: 445 rep __r; 446 }; 447 448 template<typename _Rep1, typename _Period1, 449 typename _Rep2, typename _Period2> 450 constexpr typename common_type<duration<_Rep1, _Period1>, 451 duration<_Rep2, _Period2>>::type 452 operator+(const duration<_Rep1, _Period1>& __lhs, 453 const duration<_Rep2, _Period2>& __rhs) 454 { 455 typedef duration<_Rep1, _Period1> __dur1; 456 typedef duration<_Rep2, _Period2> __dur2; 457 typedef typename common_type<__dur1,__dur2>::type __cd; 458 return __cd(__cd(__lhs).count() + __cd(__rhs).count()); 459 } 460 461 template<typename _Rep1, typename _Period1, 462 typename _Rep2, typename _Period2> 463 constexpr typename common_type<duration<_Rep1, _Period1>, 464 duration<_Rep2, _Period2>>::type 465 operator-(const duration<_Rep1, _Period1>& __lhs, 466 const duration<_Rep2, _Period2>& __rhs) 467 { 468 typedef duration<_Rep1, _Period1> __dur1; 469 typedef duration<_Rep2, _Period2> __dur2; 470 typedef typename common_type<__dur1,__dur2>::type __cd; 471 return __cd(__cd(__lhs).count() - __cd(__rhs).count()); 472 } 473 474 // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2 475 // is implicitly convertible to it. 476 // _GLIBCXX_RESOLVE_LIB_DEFECTS 477 // 3050. Conversion specification problem in chrono::duration constructor 478 template<typename _Rep1, typename _Rep2, 479 typename _CRep = typename common_type<_Rep1, _Rep2>::type> 480 using __common_rep_t = typename 481 enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type; 482 483 template<typename _Rep1, typename _Period, typename _Rep2> 484 constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> 485 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 486 { 487 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 488 __cd; 489 return __cd(__cd(__d).count() * __s); 490 } 491 492 template<typename _Rep1, typename _Rep2, typename _Period> 493 constexpr duration<__common_rep_t<_Rep2, _Rep1>, _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 499 duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _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 522 duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _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 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 return __ct(__lhs).count() == __ct(__rhs).count(); 554 } 555 556 template<typename _Rep1, typename _Period1, 557 typename _Rep2, typename _Period2> 558 constexpr bool 559 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 return __ct(__lhs).count() < __ct(__rhs).count(); 566 } 567 568 template<typename _Rep1, typename _Period1, 569 typename _Rep2, typename _Period2> 570 constexpr bool 571 operator!=(const duration<_Rep1, _Period1>& __lhs, 572 const duration<_Rep2, _Period2>& __rhs) 573 { return !(__lhs == __rhs); } 574 575 template<typename _Rep1, typename _Period1, 576 typename _Rep2, typename _Period2> 577 constexpr bool 578 operator<=(const duration<_Rep1, _Period1>& __lhs, 579 const duration<_Rep2, _Period2>& __rhs) 580 { 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() noexcept 660 { return time_point(duration::min()); } 661 662 static constexpr time_point 663 max() noexcept 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 } // namespace chrono 882 883#if __cplusplus > 201103L 884 885#define __cpp_lib_chrono_udls 201304 886 887 inline namespace literals 888 { 889 inline namespace chrono_literals 890 { 891#pragma GCC diagnostic push 892#pragma GCC diagnostic ignored "-Wliteral-suffix" 893 template<typename _Rep, unsigned long long _Val> 894 struct _Checked_integral_constant 895 : integral_constant<_Rep, static_cast<_Rep>(_Val)> 896 { 897 static_assert(_Checked_integral_constant::value >= 0 898 && _Checked_integral_constant::value == _Val, 899 "literal value cannot be represented by duration type"); 900 }; 901 902 template<typename _Dur, char... _Digits> 903 constexpr _Dur __check_overflow() 904 { 905 using _Val = __parse_int::_Parse_int<_Digits...>; 906 using _Rep = typename _Dur::rep; 907 // TODO: should be simply integral_constant<_Rep, _Val::value> 908 // but GCC doesn't reject narrowing conversions to _Rep. 909 using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>; 910 return _Dur{_CheckedVal::value}; 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 //_GLIBCXX_USE_C99_STDINT_TR1 984 985#endif // C++11 986 987#endif //_GLIBCXX_CHRONO 988