libstdc++-v3/include/std/chrono

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