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