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 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#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 zero() 280 { 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 constexpr explicit duration(const _Rep2& __rep) 328 : __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 constexpr duration(const duration<_Rep2, _Period2>& __d) 335 : __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 count() const 343 { 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 zero() 428 { 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 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 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 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() 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 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 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 operator""ms() 949 { 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 992