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 inline 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>::min(); } 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 inline 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 __ct; 363 return __ct(__lhs) += __rhs; 364 } 365 366 template<typename _Rep1, typename _Period1, 367 typename _Rep2, typename _Period2> 368 inline 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 __ct; 376 return __ct(__lhs) -= __rhs; 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 inline duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period> 390 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 391 { 392 typedef typename common_type<_Rep1, _Rep2>::type __cr; 393 return duration<__cr, _Period>(__d) *= __s; 394 } 395 396 template<typename _Rep1, typename _Period, typename _Rep2> 397 inline duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period> 398 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 399 { return __d * __s; } 400 401 template<typename _Rep1, typename _Period, typename _Rep2> 402 inline duration<typename __common_rep_type<_Rep1, typename 403 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> 404 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 405 { 406 typedef typename common_type<_Rep1, _Rep2>::type __cr; 407 return duration<__cr, _Period>(__d) /= __s; 408 } 409 410 template<typename _Rep1, typename _Period1, 411 typename _Rep2, typename _Period2> 412 inline typename common_type<_Rep1, _Rep2>::type 413 operator/(const duration<_Rep1, _Period1>& __lhs, 414 const duration<_Rep2, _Period2>& __rhs) 415 { 416 typedef duration<_Rep1, _Period1> __dur1; 417 typedef duration<_Rep2, _Period2> __dur2; 418 typedef typename common_type<__dur1,__dur2>::type __ct; 419 return __ct(__lhs).count() / __ct(__rhs).count(); 420 } 421 422 // DR 934. 423 template<typename _Rep1, typename _Period, typename _Rep2> 424 inline duration<typename __common_rep_type<_Rep1, typename 425 enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period> 426 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 427 { 428 typedef typename common_type<_Rep1, _Rep2>::type __cr; 429 return duration<__cr, _Period>(__d) %= __s; 430 } 431 432 template<typename _Rep1, typename _Period1, 433 typename _Rep2, typename _Period2> 434 inline typename common_type<duration<_Rep1, _Period1>, 435 duration<_Rep2, _Period2>>::type 436 operator%(const duration<_Rep1, _Period1>& __lhs, 437 const duration<_Rep2, _Period2>& __rhs) 438 { 439 typedef duration<_Rep1, _Period1> __dur1; 440 typedef duration<_Rep2, _Period2> __dur2; 441 typedef typename common_type<__dur1,__dur2>::type __ct; 442 return __ct(__lhs) %= __rhs; 443 } 444 445 // comparisons 446 template<typename _Rep1, typename _Period1, 447 typename _Rep2, typename _Period2> 448 inline constexpr bool 449 operator==(const duration<_Rep1, _Period1>& __lhs, 450 const duration<_Rep2, _Period2>& __rhs) 451 { 452 typedef duration<_Rep1, _Period1> __dur1; 453 typedef duration<_Rep2, _Period2> __dur2; 454 typedef typename common_type<__dur1,__dur2>::type __ct; 455 return __ct(__lhs).count() == __ct(__rhs).count(); 456 } 457 458 template<typename _Rep1, typename _Period1, 459 typename _Rep2, typename _Period2> 460 inline constexpr bool 461 operator<(const duration<_Rep1, _Period1>& __lhs, 462 const duration<_Rep2, _Period2>& __rhs) 463 { 464 typedef duration<_Rep1, _Period1> __dur1; 465 typedef duration<_Rep2, _Period2> __dur2; 466 typedef typename common_type<__dur1,__dur2>::type __ct; 467 return __ct(__lhs).count() < __ct(__rhs).count(); 468 } 469 470 template<typename _Rep1, typename _Period1, 471 typename _Rep2, typename _Period2> 472 inline constexpr bool 473 operator!=(const duration<_Rep1, _Period1>& __lhs, 474 const duration<_Rep2, _Period2>& __rhs) 475 { return !(__lhs == __rhs); } 476 477 template<typename _Rep1, typename _Period1, 478 typename _Rep2, typename _Period2> 479 inline constexpr bool 480 operator<=(const duration<_Rep1, _Period1>& __lhs, 481 const duration<_Rep2, _Period2>& __rhs) 482 { return !(__rhs < __lhs); } 483 484 template<typename _Rep1, typename _Period1, 485 typename _Rep2, typename _Period2> 486 inline constexpr bool 487 operator>(const duration<_Rep1, _Period1>& __lhs, 488 const duration<_Rep2, _Period2>& __rhs) 489 { return __rhs < __lhs; } 490 491 template<typename _Rep1, typename _Period1, 492 typename _Rep2, typename _Period2> 493 inline constexpr bool 494 operator>=(const duration<_Rep1, _Period1>& __lhs, 495 const duration<_Rep2, _Period2>& __rhs) 496 { return !(__lhs < __rhs); } 497 498 /// nanoseconds 499 typedef duration<int64_t, nano> nanoseconds; 500 501 /// microseconds 502 typedef duration<int64_t, micro> microseconds; 503 504 /// milliseconds 505 typedef duration<int64_t, milli> milliseconds; 506 507 /// seconds 508 typedef duration<int64_t> seconds; 509 510 /// minutes 511 typedef duration<int, ratio< 60>> minutes; 512 513 /// hours 514 typedef duration<int, ratio<3600>> hours; 515 516 /// time_point 517 template<typename _Clock, typename _Dur> 518 struct time_point 519 { 520 typedef _Clock clock; 521 typedef _Dur duration; 522 typedef typename duration::rep rep; 523 typedef typename duration::period period; 524 525 constexpr time_point() : __d(duration::zero()) 526 { } 527 528 constexpr explicit time_point(const duration& __dur) 529 : __d(__dur) 530 { } 531 532 // conversions 533 template<typename _Dur2> 534 constexpr time_point(const time_point<clock, _Dur2>& __t) 535 : __d(__t.time_since_epoch()) 536 { } 537 538 // observer 539 constexpr duration 540 time_since_epoch() const 541 { return __d; } 542 543 // arithmetic 544 time_point& 545 operator+=(const duration& __dur) 546 { 547 __d += __dur; 548 return *this; 549 } 550 551 time_point& 552 operator-=(const duration& __dur) 553 { 554 __d -= __dur; 555 return *this; 556 } 557 558 // special values 559 static constexpr time_point 560 min() 561 { return time_point(duration::min()); } 562 563 static constexpr time_point 564 max() 565 { return time_point(duration::max()); } 566 567 private: 568 duration __d; 569 }; 570 571 /// time_point_cast 572 template<typename _ToDur, typename _Clock, typename _Dur> 573 inline constexpr typename enable_if<__is_duration<_ToDur>::value, 574 time_point<_Clock, _ToDur>>::type 575 time_point_cast(const time_point<_Clock, _Dur>& __t) 576 { 577 typedef time_point<_Clock, _ToDur> __time_point; 578 return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); 579 } 580 581 template<typename _Clock, typename _Dur1, 582 typename _Rep2, typename _Period2> 583 inline time_point<_Clock, 584 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 585 operator+(const time_point<_Clock, _Dur1>& __lhs, 586 const duration<_Rep2, _Period2>& __rhs) 587 { 588 typedef duration<_Rep2, _Period2> __dur2; 589 typedef typename common_type<_Dur1,__dur2>::type __ct; 590 typedef time_point<_Clock, __ct> __time_point; 591 return __time_point(__lhs) += __rhs; 592 } 593 594 template<typename _Rep1, typename _Period1, 595 typename _Clock, typename _Dur2> 596 inline time_point<_Clock, 597 typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> 598 operator+(const duration<_Rep1, _Period1>& __lhs, 599 const time_point<_Clock, _Dur2>& __rhs) 600 { return __rhs + __lhs; } 601 602 template<typename _Clock, typename _Dur1, 603 typename _Rep2, typename _Period2> 604 inline time_point<_Clock, 605 typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> 606 operator-(const time_point<_Clock, _Dur1>& __lhs, 607 const duration<_Rep2, _Period2>& __rhs) 608 { return __lhs + (-__rhs); } 609 610 template<typename _Clock, typename _Dur1, typename _Dur2> 611 inline typename common_type<_Dur1, _Dur2>::type 612 operator-(const time_point<_Clock, _Dur1>& __lhs, 613 const time_point<_Clock, _Dur2>& __rhs) 614 { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } 615 616 template<typename _Clock, typename _Dur1, typename _Dur2> 617 inline constexpr bool 618 operator==(const time_point<_Clock, _Dur1>& __lhs, 619 const time_point<_Clock, _Dur2>& __rhs) 620 { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } 621 622 template<typename _Clock, typename _Dur1, typename _Dur2> 623 inline constexpr bool 624 operator!=(const time_point<_Clock, _Dur1>& __lhs, 625 const time_point<_Clock, _Dur2>& __rhs) 626 { return !(__lhs == __rhs); } 627 628 template<typename _Clock, typename _Dur1, typename _Dur2> 629 inline constexpr bool 630 operator<(const time_point<_Clock, _Dur1>& __lhs, 631 const time_point<_Clock, _Dur2>& __rhs) 632 { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } 633 634 template<typename _Clock, typename _Dur1, typename _Dur2> 635 inline constexpr bool 636 operator<=(const time_point<_Clock, _Dur1>& __lhs, 637 const time_point<_Clock, _Dur2>& __rhs) 638 { return !(__rhs < __lhs); } 639 640 template<typename _Clock, typename _Dur1, typename _Dur2> 641 inline constexpr bool 642 operator>(const time_point<_Clock, _Dur1>& __lhs, 643 const time_point<_Clock, _Dur2>& __rhs) 644 { return __rhs < __lhs; } 645 646 template<typename _Clock, typename _Dur1, typename _Dur2> 647 inline constexpr bool 648 operator>=(const time_point<_Clock, _Dur1>& __lhs, 649 const time_point<_Clock, _Dur2>& __rhs) 650 { return !(__lhs < __rhs); } 651 652 /// system_clock 653 struct system_clock 654 { 655#ifdef _GLIBCXX_USE_CLOCK_REALTIME 656 typedef chrono::nanoseconds duration; 657#elif defined(_GLIBCXX_USE_GETTIMEOFDAY) 658 typedef chrono::microseconds duration; 659#else 660 typedef chrono::seconds duration; 661#endif 662 663 typedef duration::rep rep; 664 typedef duration::period period; 665 typedef chrono::time_point<system_clock, duration> time_point; 666 667 static_assert(system_clock::duration::min() 668 < system_clock::duration::zero(), 669 "a clock's minimum duration cannot be less than its epoch"); 670 671 static constexpr bool is_monotonic = false; 672 673 static time_point 674 now() throw (); 675 676 // Map to C API 677 static std::time_t 678 to_time_t(const time_point& __t) 679 { 680 return std::time_t(duration_cast<chrono::seconds> 681 (__t.time_since_epoch()).count()); 682 } 683 684 static time_point 685 from_time_t(std::time_t __t) 686 { 687 typedef chrono::time_point<system_clock, seconds> __from; 688 return time_point_cast<system_clock::duration> 689 (__from(chrono::seconds(__t))); 690 } 691 }; 692 693#ifdef _GLIBCXX_USE_CLOCK_MONOTONIC 694 /// monotonic_clock 695 struct monotonic_clock 696 { 697 typedef chrono::nanoseconds duration; 698 typedef duration::rep rep; 699 typedef duration::period period; 700 typedef chrono::time_point<monotonic_clock, duration> time_point; 701 702 static constexpr bool is_monotonic = true; 703 704 static time_point 705 now(); 706 }; 707#else 708 typedef system_clock monotonic_clock; 709#endif 710 711 typedef system_clock high_resolution_clock; 712 713 _GLIBCXX_END_NAMESPACE_VERSION 714 } // namespace chrono 715 716 // @} group chrono 717} // namespace 718 719#endif //_GLIBCXX_USE_C99_STDINT_TR1 720 721#endif //__GXX_EXPERIMENTAL_CXX0X__ 722 723#endif //_GLIBCXX_CHRONO 724