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