1// <chrono> -*- C++ -*- 2 3// Copyright (C) 2008, 2009, 2010, 2011 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#ifndef __GXX_EXPERIMENTAL_CXX0X__ 35# include <bits/c++0x_warning.h> 36#else 37 38#include <ratio> 39#include <type_traits> 40#include <limits> 41#include <ctime> 42 43#ifdef _GLIBCXX_USE_C99_STDINT_TR1 44 45namespace std _GLIBCXX_VISIBILITY(default) 46{ 47 /** 48 * @defgroup chrono Time 49 * @ingroup utilities 50 * 51 * Classes and functions for time. 52 * @{ 53 */ 54 55 /** @namespace std::chrono 56 * @brief ISO C++ 0x entities sub namespace for time and date. 57 */ 58 namespace chrono 59 { 60 _GLIBCXX_BEGIN_NAMESPACE_VERSION 61 62 template<typename _Rep, typename _Period = ratio<1>> 63 struct duration; 64 65 template<typename _Clock, typename _Dur = typename _Clock::duration> 66 struct time_point; 67 68 _GLIBCXX_END_NAMESPACE_VERSION 69 } 70 71_GLIBCXX_BEGIN_NAMESPACE_VERSION 72 // 20.8.2.3 specialization of common_type (for duration) 73 template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> 74 struct common_type<chrono::duration<_Rep1, _Period1>, 75 chrono::duration<_Rep2, _Period2>> 76 { 77 private: 78 typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num; 79 typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den; 80 typedef typename common_type<_Rep1, _Rep2>::type __cr; 81 typedef ratio<__gcd_num::value, 82 (_Period1::den / __gcd_den::value) * _Period2::den> __r; 83 84 public: 85 typedef chrono::duration<__cr, __r> type; 86 }; 87 88 // 20.8.2.3 specialization of common_type (for time_point) 89 template<typename _Clock, typename _Dur1, typename _Dur2> 90 struct common_type<chrono::time_point<_Clock, _Dur1>, 91 chrono::time_point<_Clock, _Dur2>> 92 { 93 private: 94 typedef typename common_type<_Dur1, _Dur2>::type __ct; 95 96 public: 97 typedef chrono::time_point<_Clock, __ct> type; 98 }; 99_GLIBCXX_END_NAMESPACE_VERSION 100 101 namespace chrono 102 { 103 _GLIBCXX_BEGIN_NAMESPACE_VERSION 104 105 // Primary template for duration_cast impl. 106 template<typename _ToDur, typename _CF, typename _CR, 107 bool _NumIsOne = false, bool _DenIsOne = false> 108 struct __duration_cast_impl 109 { 110 template<typename _Rep, typename _Period> 111 static constexpr _ToDur 112 __cast(const duration<_Rep, _Period>& __d) 113 { 114 typedef typename _ToDur::rep __to_rep; 115 return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) 116 * static_cast<_CR>(_CF::num) 117 / static_cast<_CR>(_CF::den))); 118 } 119 }; 120 121 template<typename _ToDur, typename _CF, typename _CR> 122 struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> 123 { 124 template<typename _Rep, typename _Period> 125 static constexpr _ToDur 126 __cast(const duration<_Rep, _Period>& __d) 127 { 128 typedef typename _ToDur::rep __to_rep; 129 return _ToDur(static_cast<__to_rep>(__d.count())); 130 } 131 }; 132 133 template<typename _ToDur, typename _CF, typename _CR> 134 struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> 135 { 136 template<typename _Rep, typename _Period> 137 static constexpr _ToDur 138 __cast(const duration<_Rep, _Period>& __d) 139 { 140 typedef typename _ToDur::rep __to_rep; 141 return _ToDur(static_cast<__to_rep>( 142 static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 143 } 144 }; 145 146 template<typename _ToDur, typename _CF, typename _CR> 147 struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> 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::num))); 156 } 157 }; 158 159 template<typename _Tp> 160 struct __is_duration 161 : std::false_type 162 { }; 163 164 template<typename _Rep, typename _Period> 165 struct __is_duration<duration<_Rep, _Period>> 166 : std::true_type 167 { }; 168 169 /// duration_cast 170 template<typename _ToDur, typename _Rep, typename _Period> 171 constexpr typename enable_if<__is_duration<_ToDur>::value, 172 _ToDur>::type 173 duration_cast(const duration<_Rep, _Period>& __d) 174 { 175 typedef typename _ToDur::period __to_period; 176 typedef typename _ToDur::rep __to_rep; 177 typedef ratio_divide<_Period, __to_period> __r_div; 178 typedef typename __r_div::type __cf; 179 typedef typename common_type<__to_rep, _Rep, intmax_t>::type 180 __cr; 181 typedef __duration_cast_impl<_ToDur, __cf, __cr, 182 __cf::num == 1, __cf::den == 1> __dc; 183 return __dc::__cast(__d); 184 } 185 186 /// treat_as_floating_point 187 template<typename _Rep> 188 struct treat_as_floating_point 189 : is_floating_point<_Rep> 190 { }; 191 192 /// duration_values 193 template<typename _Rep> 194 struct duration_values 195 { 196 static constexpr _Rep 197 zero() 198 { return _Rep(0); } 199 200 static constexpr _Rep 201 max() 202 { return numeric_limits<_Rep>::max(); } 203 204 static constexpr _Rep 205 min() 206 { return numeric_limits<_Rep>::lowest(); } 207 }; 208 209 template<typename T> 210 struct __is_ratio 211 : std::false_type 212 { }; 213 214 template<intmax_t _Num, intmax_t _Den> 215 struct __is_ratio<ratio<_Num, _Den>> 216 : std::true_type 217 { }; 218 219 /// duration 220 template<typename _Rep, typename _Period> 221 struct duration 222 { 223 typedef _Rep rep; 224 typedef _Period period; 225 226 static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); 227 static_assert(__is_ratio<_Period>::value, 228 "period must be a specialization of ratio"); 229 static_assert(_Period::num > 0, "period must be positive"); 230 231 // 20.8.3.1 construction / copy / destroy 232 constexpr duration() : __r() { } 233 234 constexpr duration(const duration&) = default; 235 236 template<typename _Rep2, typename = typename 237 enable_if<is_convertible<_Rep2, rep>::value 238 && (treat_as_floating_point<rep>::value 239 || !treat_as_floating_point<_Rep2>::value)>::type> 240 constexpr explicit duration(const _Rep2& __rep) 241 : __r(static_cast<rep>(__rep)) { } 242 243 template<typename _Rep2, typename _Period2, typename = typename 244 enable_if<treat_as_floating_point<rep>::value 245 || (ratio_divide<_Period2, period>::type::den == 1 246 && !treat_as_floating_point<_Rep2>::value)>::type> 247 constexpr duration(const duration<_Rep2, _Period2>& __d) 248 : __r(duration_cast<duration>(__d).count()) { } 249 250 ~duration() = default; 251 duration& operator=(const duration&) = default; 252 253 // 20.8.3.2 observer 254 constexpr rep 255 count() const 256 { return __r; } 257 258 // 20.8.3.3 arithmetic 259 constexpr duration 260 operator+() const 261 { return *this; } 262 263 constexpr duration 264 operator-() const 265 { return duration(-__r); } 266 267 duration& 268 operator++() 269 { 270 ++__r; 271 return *this; 272 } 273 274 duration 275 operator++(int) 276 { return duration(__r++); } 277 278 duration& 279 operator--() 280 { 281 --__r; 282 return *this; 283 } 284 285 duration 286 operator--(int) 287 { return duration(__r--); } 288 289 duration& 290 operator+=(const duration& __d) 291 { 292 __r += __d.count(); 293 return *this; 294 } 295 296 duration& 297 operator-=(const duration& __d) 298 { 299 __r -= __d.count(); 300 return *this; 301 } 302 303 duration& 304 operator*=(const rep& __rhs) 305 { 306 __r *= __rhs; 307 return *this; 308 } 309 310 duration& 311 operator/=(const rep& __rhs) 312 { 313 __r /= __rhs; 314 return *this; 315 } 316 317 // DR 934. 318 template<typename _Rep2 = rep> 319 typename enable_if<!treat_as_floating_point<_Rep2>::value, 320 duration&>::type 321 operator%=(const rep& __rhs) 322 { 323 __r %= __rhs; 324 return *this; 325 } 326 327 template<typename _Rep2 = rep> 328 typename enable_if<!treat_as_floating_point<_Rep2>::value, 329 duration&>::type 330 operator%=(const duration& __d) 331 { 332 __r %= __d.count(); 333 return *this; 334 } 335 336 // 20.8.3.4 special values 337 static constexpr duration 338 zero() 339 { return duration(duration_values<rep>::zero()); } 340 341 static constexpr duration 342 min() 343 { return duration(duration_values<rep>::min()); } 344 345 static constexpr duration 346 max() 347 { return duration(duration_values<rep>::max()); } 348 349 private: 350 rep __r; 351 }; 352 353 template<typename _Rep1, typename _Period1, 354 typename _Rep2, typename _Period2> 355 constexpr typename common_type<duration<_Rep1, _Period1>, 356 duration<_Rep2, _Period2>>::type 357 operator+(const duration<_Rep1, _Period1>& __lhs, 358 const duration<_Rep2, _Period2>& __rhs) 359 { 360 typedef duration<_Rep1, _Period1> __dur1; 361 typedef duration<_Rep2, _Period2> __dur2; 362 typedef typename common_type<__dur1,__dur2>::type __cd; 363 return __cd(__cd(__lhs).count() + __cd(__rhs).count()); 364 } 365 366 template<typename _Rep1, typename _Period1, 367 typename _Rep2, typename _Period2> 368 constexpr typename common_type<duration<_Rep1, _Period1>, 369 duration<_Rep2, _Period2>>::type 370 operator-(const duration<_Rep1, _Period1>& __lhs, 371 const duration<_Rep2, _Period2>& __rhs) 372 { 373 typedef duration<_Rep1, _Period1> __dur1; 374 typedef duration<_Rep2, _Period2> __dur2; 375 typedef typename common_type<__dur1,__dur2>::type __cd; 376 return __cd(__cd(__lhs).count() - __cd(__rhs).count()); 377 } 378 379 template<typename _Rep1, typename _Rep2, bool = 380 is_convertible<_Rep2, 381 typename common_type<_Rep1, _Rep2>::type>::value> 382 struct __common_rep_type { }; 383 384 template<typename _Rep1, typename _Rep2> 385 struct __common_rep_type<_Rep1, _Rep2, true> 386 { typedef typename common_type<_Rep1, _Rep2>::type type; }; 387 388 template<typename _Rep1, typename _Period, typename _Rep2> 389 constexpr 390 duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period> 391 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 392 { 393 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 394 __cd; 395 return __cd(__cd(__d).count() * __s); 396 } 397 398 template<typename _Rep1, typename _Rep2, typename _Period> 399 constexpr 400 duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period> 401 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 402 { return __d * __s; } 403 404 template<typename _Rep1, typename _Period, typename _Rep2> 405 constexpr duration<typename __common_rep_type<_Rep1, typename 406 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> 407 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 408 { 409 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> 410 __cd; 411 return __cd(__cd(__d).count() / __s); 412 } 413 414 template<typename _Rep1, typename _Period1, 415 typename _Rep2, typename _Period2> 416 constexpr typename common_type<_Rep1, _Rep2>::type 417 operator/(const duration<_Rep1, _Period1>& __lhs, 418 const duration<_Rep2, _Period2>& __rhs) 419 { 420 typedef duration<_Rep1, _Period1> __dur1; 421 typedef duration<_Rep2, _Period2> __dur2; 422 typedef typename common_type<__dur1,__dur2>::type __cd; 423 return __cd(__lhs).count() / __cd(__rhs).count(); 424 } 425 426 // DR 934. 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<duration<_Rep1, _Period1>, 440 duration<_Rep2, _Period2>>::type 441 operator%(const duration<_Rep1, _Period1>& __lhs, 442 const duration<_Rep2, _Period2>& __rhs) 443 { 444 typedef duration<_Rep1, _Period1> __dur1; 445 typedef duration<_Rep2, _Period2> __dur2; 446 typedef typename common_type<__dur1,__dur2>::type __cd; 447 return __cd(__cd(__lhs).count() % __cd(__rhs).count()); 448 } 449 450 // comparisons 451 template<typename _Rep1, typename _Period1, 452 typename _Rep2, typename _Period2> 453 constexpr bool 454 operator==(const duration<_Rep1, _Period1>& __lhs, 455 const duration<_Rep2, _Period2>& __rhs) 456 { 457 typedef duration<_Rep1, _Period1> __dur1; 458 typedef duration<_Rep2, _Period2> __dur2; 459 typedef typename common_type<__dur1,__dur2>::type __ct; 460 return __ct(__lhs).count() == __ct(__rhs).count(); 461 } 462 463 template<typename _Rep1, typename _Period1, 464 typename _Rep2, typename _Period2> 465 constexpr bool 466 operator<(const duration<_Rep1, _Period1>& __lhs, 467 const duration<_Rep2, _Period2>& __rhs) 468 { 469 typedef duration<_Rep1, _Period1> __dur1; 470 typedef duration<_Rep2, _Period2> __dur2; 471 typedef typename common_type<__dur1,__dur2>::type __ct; 472 return __ct(__lhs).count() < __ct(__rhs).count(); 473 } 474 475 template<typename _Rep1, typename _Period1, 476 typename _Rep2, typename _Period2> 477 constexpr bool 478 operator!=(const duration<_Rep1, _Period1>& __lhs, 479 const duration<_Rep2, _Period2>& __rhs) 480 { return !(__lhs == __rhs); } 481 482 template<typename _Rep1, typename _Period1, 483 typename _Rep2, typename _Period2> 484 constexpr bool 485 operator<=(const duration<_Rep1, _Period1>& __lhs, 486 const duration<_Rep2, _Period2>& __rhs) 487 { return !(__rhs < __lhs); } 488 489 template<typename _Rep1, typename _Period1, 490 typename _Rep2, typename _Period2> 491 constexpr bool 492 operator>(const duration<_Rep1, _Period1>& __lhs, 493 const duration<_Rep2, _Period2>& __rhs) 494 { return __rhs < __lhs; } 495 496 template<typename _Rep1, typename _Period1, 497 typename _Rep2, typename _Period2> 498 constexpr bool 499 operator>=(const duration<_Rep1, _Period1>& __lhs, 500 const duration<_Rep2, _Period2>& __rhs) 501 { return !(__lhs < __rhs); } 502 503 /// nanoseconds 504 typedef duration<int64_t, nano> nanoseconds; 505 506 /// microseconds 507 typedef duration<int64_t, micro> microseconds; 508 509 /// milliseconds 510 typedef duration<int64_t, milli> milliseconds; 511 512 /// seconds 513 typedef duration<int64_t> seconds; 514 515 /// minutes 516 typedef duration<int, ratio< 60>> minutes; 517 518 /// hours 519 typedef duration<int, ratio<3600>> hours; 520 521 /// time_point 522 template<typename _Clock, typename _Dur> 523 struct time_point 524 { 525 typedef _Clock clock; 526 typedef _Dur duration; 527 typedef typename duration::rep rep; 528 typedef typename duration::period period; 529 530 constexpr time_point() : __d(duration::zero()) 531 { } 532 533 constexpr explicit time_point(const duration& __dur) 534 : __d(__dur) 535 { } 536 537 // conversions 538 template<typename _Dur2> 539 constexpr time_point(const time_point<clock, _Dur2>& __t) 540 : __d(__t.time_since_epoch()) 541 { } 542 543 // observer 544 constexpr duration 545 time_since_epoch() const 546 { return __d; } 547 548 // arithmetic 549 time_point& 550 operator+=(const duration& __dur) 551 { 552 __d += __dur; 553 return *this; 554 } 555 556 time_point& 557 operator-=(const duration& __dur) 558 { 559 __d -= __dur; 560 return *this; 561 } 562 563 // special values 564 static constexpr time_point 565 min() 566 { return time_point(duration::min()); } 567 568 static constexpr time_point 569 max() 570 { return time_point(duration::max()); } 571 572 private: 573 duration __d; 574 }; 575 576 /// time_point_cast 577 template<typename _ToDur, typename _Clock, typename _Dur> 578 constexpr typename enable_if<__is_duration<_ToDur>::value, 579 time_point<_Clock, _ToDur>>::type 580 time_point_cast(const time_point<_Clock, _Dur>& __t) 581 { 582 typedef time_point<_Clock, _ToDur> __time_point; 583 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); 584 } 585 586 template<typename _Clock, typename _Dur1, 587 typename _Rep2, typename _Period2> 588 constexpr time_point<_Clock, 589 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 590 operator+(const time_point<_Clock, _Dur1>& __lhs, 591 const duration<_Rep2, _Period2>& __rhs) 592 { 593 typedef duration<_Rep2, _Period2> __dur2; 594 typedef typename common_type<_Dur1,__dur2>::type __ct; 595 typedef time_point<_Clock, __ct> __time_point; 596 return __time_point(__lhs.time_since_epoch() + __rhs); 597 } 598 599 template<typename _Rep1, typename _Period1, 600 typename _Clock, typename _Dur2> 601 constexpr time_point<_Clock, 602 typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> 603 operator+(const duration<_Rep1, _Period1>& __lhs, 604 const time_point<_Clock, _Dur2>& __rhs) 605 { 606 typedef duration<_Rep1, _Period1> __dur1; 607 typedef typename common_type<__dur1,_Dur2>::type __ct; 608 typedef time_point<_Clock, __ct> __time_point; 609 return __time_point(__rhs.time_since_epoch() + __lhs); 610 } 611 612 template<typename _Clock, typename _Dur1, 613 typename _Rep2, typename _Period2> 614 constexpr time_point<_Clock, 615 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 616 operator-(const time_point<_Clock, _Dur1>& __lhs, 617 const duration<_Rep2, _Period2>& __rhs) 618 { 619 typedef duration<_Rep2, _Period2> __dur2; 620 typedef typename common_type<_Dur1,__dur2>::type __ct; 621 typedef time_point<_Clock, __ct> __time_point; 622 return __time_point(__lhs.time_since_epoch() -__rhs); 623 } 624 625 template<typename _Clock, typename _Dur1, typename _Dur2> 626 constexpr typename common_type<_Dur1, _Dur2>::type 627 operator-(const time_point<_Clock, _Dur1>& __lhs, 628 const time_point<_Clock, _Dur2>& __rhs) 629 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } 630 631 template<typename _Clock, typename _Dur1, typename _Dur2> 632 constexpr bool 633 operator==(const time_point<_Clock, _Dur1>& __lhs, 634 const time_point<_Clock, _Dur2>& __rhs) 635 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } 636 637 template<typename _Clock, typename _Dur1, typename _Dur2> 638 constexpr bool 639 operator!=(const time_point<_Clock, _Dur1>& __lhs, 640 const time_point<_Clock, _Dur2>& __rhs) 641 { return !(__lhs == __rhs); } 642 643 template<typename _Clock, typename _Dur1, typename _Dur2> 644 constexpr bool 645 operator<(const time_point<_Clock, _Dur1>& __lhs, 646 const time_point<_Clock, _Dur2>& __rhs) 647 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } 648 649 template<typename _Clock, typename _Dur1, typename _Dur2> 650 constexpr bool 651 operator<=(const time_point<_Clock, _Dur1>& __lhs, 652 const time_point<_Clock, _Dur2>& __rhs) 653 { return !(__rhs < __lhs); } 654 655 template<typename _Clock, typename _Dur1, typename _Dur2> 656 constexpr bool 657 operator>(const time_point<_Clock, _Dur1>& __lhs, 658 const time_point<_Clock, _Dur2>& __rhs) 659 { return __rhs < __lhs; } 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 < __rhs); } 666 667 /// system_clock 668 struct system_clock 669 { 670#ifdef _GLIBCXX_USE_CLOCK_REALTIME 671 typedef chrono::nanoseconds duration; 672#elif defined(_GLIBCXX_USE_GETTIMEOFDAY) 673 typedef chrono::microseconds duration; 674#else 675 typedef chrono::seconds duration; 676#endif 677 678 typedef duration::rep rep; 679 typedef duration::period period; 680 typedef chrono::time_point<system_clock, duration> time_point; 681 682 static_assert(system_clock::duration::min() 683 < system_clock::duration::zero(), 684 "a clock's minimum duration cannot be less than its epoch"); 685 686 static constexpr bool is_steady = false; 687 688 static time_point 689 now() noexcept; 690 691 // Map to C API 692 static std::time_t 693 to_time_t(const time_point& __t) noexcept 694 { 695 return std::time_t(duration_cast<chrono::seconds> 696 (__t.time_since_epoch()).count()); 697 } 698 699 static time_point 700 from_time_t(std::time_t __t) noexcept 701 { 702 typedef chrono::time_point<system_clock, seconds> __from; 703 return time_point_cast<system_clock::duration> 704 (__from(chrono::seconds(__t))); 705 } 706 }; 707 708#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC 709 /// steady_clock 710 struct steady_clock 711 { 712 typedef chrono::nanoseconds duration; 713 typedef duration::rep rep; 714 typedef duration::period period; 715 typedef chrono::time_point<steady_clock, duration> time_point; 716 717 static constexpr bool is_steady = true; 718 719 static time_point 720 now() noexcept; 721 }; 722#else 723 typedef system_clock steady_clock; 724#endif 725 726 typedef system_clock high_resolution_clock; 727 728 _GLIBCXX_END_NAMESPACE_VERSION 729 } // namespace chrono 730 731 // @} group chrono 732} // namespace 733 734#endif //_GLIBCXX_USE_C99_STDINT_TR1 735 736#endif //__GXX_EXPERIMENTAL_CXX0X__ 737 738#endif //_GLIBCXX_CHRONO 739