chrono

Go to the documentation of this file.
00001 // <chrono> -*- C++ -*-
00002 
00003 // Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 3, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // Under Section 7 of GPL version 3, you are granted additional
00017 // permissions described in the GCC Runtime Library Exception, version
00018 // 3.1, as published by the Free Software Foundation.
00019 
00020 // You should have received a copy of the GNU General Public License and
00021 // a copy of the GCC Runtime Library Exception along with this program;
00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00023 // <http://www.gnu.org/licenses/>.
00024 
00025 /** @file include/chrono
00026  *  This is a Standard C++ Library header.
00027  */
00028 
00029 #ifndef _GLIBCXX_CHRONO
00030 #define _GLIBCXX_CHRONO 1
00031 
00032 #pragma GCC system_header
00033 
00034 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00035 # include <bits/c++0x_warning.h>
00036 #else
00037 
00038 #ifdef _GLIBCXX_INCLUDE_AS_TR1
00039 #  error C++0x header cannot be included from TR1 header
00040 #endif
00041 
00042 #include <ratio>
00043 #include <type_traits>
00044 #include <limits>
00045 #include <ctime>
00046 
00047 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
00048 
00049 namespace std 
00050 {
00051   /**
00052    * @defgroup chrono Time
00053    * @ingroup utilities
00054    *
00055    * Classes and functions for time.
00056    * @{
00057    */
00058 
00059   /** @namespace std::chrono
00060    *  @brief ISO C++ 0x entities sub namespace for time and date.
00061    */
00062   namespace chrono
00063   {
00064     template<typename _Rep, typename _Period = ratio<1>>
00065       struct duration;
00066 
00067     template<typename _Clock, typename _Duration = typename _Clock::duration>
00068       struct time_point;
00069   }
00070 
00071   // 20.8.2.3 specialization of common_type (for duration)
00072   template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
00073     struct common_type<chrono::duration<_Rep1, _Period1>,
00074                        chrono::duration<_Rep2, _Period2>>
00075     {
00076       typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
00077         ratio<__static_gcd<_Period1::num, _Period2::num>::value,
00078         (_Period1::den / __static_gcd<_Period1::den, _Period2::den>::value)
00079         * _Period2::den>> type;
00080     };
00081   
00082   // 20.8.2.3 specialization of common_type (for time_point)
00083   template<typename _Clock, typename _Duration1, typename _Duration2>
00084     struct common_type<chrono::time_point<_Clock, _Duration1>,
00085                        chrono::time_point<_Clock, _Duration2>>
00086     {
00087       typedef chrono::time_point<_Clock, 
00088         typename common_type<_Duration1, _Duration2>::type> type;
00089     };
00090 
00091   namespace chrono 
00092   {
00093     // Primary template for duration_cast impl.
00094     template<typename _ToDuration, typename _CF, typename _CR,
00095              bool _NumIsOne = false, bool _DenIsOne = false>
00096       struct __duration_cast_impl
00097       {
00098         template<typename _Rep, typename _Period>
00099           static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00100           {
00101             return _ToDuration(static_cast<
00102               typename _ToDuration::rep>(static_cast<_CR>(__d.count())
00103               * static_cast<_CR>(_CF::num)
00104               / static_cast<_CR>(_CF::den)));
00105           }
00106       };
00107 
00108     template<typename _ToDuration, typename _CF, typename _CR>
00109       struct __duration_cast_impl<_ToDuration, _CF, _CR, true, true>
00110       {
00111         template<typename _Rep, typename _Period>
00112           static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00113           {
00114             return _ToDuration(
00115               static_cast<typename _ToDuration::rep>(__d.count()));
00116           }
00117       };
00118 
00119     template<typename _ToDuration, typename _CF, typename _CR>
00120       struct __duration_cast_impl<_ToDuration, _CF, _CR, true, false>
00121       {
00122         template<typename _Rep, typename _Period>
00123           static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00124           {
00125             return _ToDuration(static_cast<typename _ToDuration::rep>(
00126               static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); 
00127           }
00128       };
00129 
00130     template<typename _ToDuration, typename _CF, typename _CR>
00131       struct __duration_cast_impl<_ToDuration, _CF, _CR, false, true>
00132       {
00133         template<typename _Rep, typename _Period>
00134           static _ToDuration __cast(const duration<_Rep, _Period>& __d)
00135           {
00136             return _ToDuration(static_cast<typename _ToDuration::rep>(
00137               static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
00138           }
00139       };
00140 
00141     template<typename _Tp>
00142       struct __is_duration
00143       : std::false_type
00144       { };
00145 
00146     template<typename _Rep, typename _Period>
00147       struct __is_duration<duration<_Rep, _Period>>
00148       : std::true_type
00149       { };
00150 
00151     /// duration_cast
00152     template<typename _ToDuration, typename _Rep, typename _Period>
00153       inline typename enable_if<__is_duration<_ToDuration>::value,
00154                 _ToDuration>::type
00155       duration_cast(const duration<_Rep, _Period>& __d)
00156       {
00157         typedef typename
00158           ratio_divide<_Period, typename _ToDuration::period>::type __cf;
00159         typedef typename
00160           common_type<typename _ToDuration::rep, _Rep, intmax_t>::type __cr;
00161 
00162         return __duration_cast_impl<_ToDuration, __cf, __cr,
00163           __cf::num == 1, __cf::den == 1>::__cast(__d);
00164       }
00165 
00166     /// treat_as_floating_point
00167     template<typename _Rep>
00168       struct treat_as_floating_point
00169       : is_floating_point<_Rep>
00170       { };
00171 
00172     /// duration_values
00173     template<typename _Rep>
00174       struct duration_values
00175       {
00176         static const _Rep
00177         zero()
00178         { return _Rep(0); }
00179         
00180         static const _Rep
00181         max()
00182         { return numeric_limits<_Rep>::max(); }
00183         
00184         static const _Rep
00185         min()
00186         { return numeric_limits<_Rep>::min(); }
00187       };
00188 
00189     template<typename T>
00190       struct __is_ratio
00191       : std::false_type
00192       { };
00193 
00194     template<intmax_t _Num, intmax_t _Den>
00195       struct __is_ratio<ratio<_Num, _Den>>
00196       : std::true_type
00197       { };
00198 
00199     /// duration
00200     template<typename _Rep, typename _Period>
00201       struct duration
00202       {
00203     static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
00204     static_assert(__is_ratio<_Period>::value, 
00205               "period must be a specialization of ratio");
00206         static_assert(_Period::num > 0, "period must be positive");
00207         
00208         typedef _Rep    rep;
00209         typedef _Period period;
00210         
00211         // 20.8.3.1 construction / copy / destroy
00212     duration() = default;
00213 
00214         template<typename _Rep2, typename = typename
00215            enable_if<is_convertible<_Rep2, rep>::value
00216              && (treat_as_floating_point<rep>::value
00217                  || !treat_as_floating_point<_Rep2>::value)>::type>
00218           explicit duration(const _Rep2& __rep)
00219           : __r(static_cast<rep>(__rep)) { }
00220 
00221         template<typename _Rep2, typename _Period2, typename = typename
00222            enable_if<treat_as_floating_point<rep>::value 
00223              || (ratio_divide<_Period2, period>::type::den == 1
00224                  && !treat_as_floating_point<_Rep2>::value)>::type>
00225           duration(const duration<_Rep2, _Period2>& __d)
00226           : __r(duration_cast<duration>(__d).count()) { }
00227 
00228     ~duration() = default;
00229     duration(const duration&) = default;
00230     duration& operator=(const duration&) = default;
00231 
00232         // 20.8.3.2 observer
00233         rep
00234         count() const
00235         { return __r; }
00236 
00237         // 20.8.3.3 arithmetic
00238         duration
00239         operator+() const 
00240         { return *this; }
00241 
00242         duration
00243         operator-() const
00244         { return duration(-__r); }
00245 
00246         duration&
00247         operator++()
00248         {
00249           ++__r;
00250           return *this;
00251         }
00252 
00253         duration
00254         operator++(int)
00255         { return duration(__r++); }
00256 
00257         duration&
00258         operator--()
00259         {
00260           --__r;
00261           return *this;
00262         }
00263 
00264         duration
00265         operator--(int)
00266         { return duration(__r--); }
00267         
00268         duration&
00269         operator+=(const duration& __d)
00270         {
00271           __r += __d.count();
00272           return *this;
00273         }
00274 
00275         duration&
00276         operator-=(const duration& __d)
00277         {
00278           __r -= __d.count();
00279           return *this;
00280         }
00281 
00282         duration&
00283         operator*=(const rep& __rhs)
00284         {
00285           __r *= __rhs;
00286           return *this;
00287         }
00288 
00289         duration&
00290         operator/=(const rep& __rhs)
00291         {
00292           __r /= __rhs;
00293           return *this;
00294         }
00295 
00296     // DR 934.
00297     template<typename _Rep2 = rep>
00298       typename enable_if<!treat_as_floating_point<_Rep2>::value,
00299                  duration&>::type
00300       operator%=(const rep& __rhs)
00301       {
00302         __r %= __rhs;
00303         return *this;
00304       }
00305 
00306     template<typename _Rep2 = rep>
00307       typename enable_if<!treat_as_floating_point<_Rep2>::value,
00308                  duration&>::type
00309       operator%=(const duration& __d)
00310       {
00311         __r %= __d.count();
00312         return *this;
00313       }
00314 
00315         // 20.8.3.4 special values
00316         // TODO: These should be constexprs.
00317         static const duration
00318         zero()
00319         { return duration(duration_values<rep>::zero()); }
00320 
00321         static const duration
00322         min()
00323         { return duration(duration_values<rep>::min()); }
00324       
00325         static const duration
00326         max()
00327         { return duration(duration_values<rep>::max()); }
00328 
00329       private:
00330         rep __r;
00331       };
00332 
00333     template<typename _Rep1, typename _Period1,
00334              typename _Rep2, typename _Period2>
00335       inline typename common_type<duration<_Rep1, _Period1>, 
00336                                   duration<_Rep2, _Period2>>::type
00337       operator+(const duration<_Rep1, _Period1>& __lhs, 
00338                 const duration<_Rep2, _Period2>& __rhs)
00339       {
00340         typedef typename common_type<duration<_Rep1, _Period1>, 
00341                                      duration<_Rep2, _Period2>>::type __ct;
00342         return __ct(__lhs) += __rhs;
00343       }
00344 
00345     template<typename _Rep1, typename _Period1, 
00346              typename _Rep2, typename _Period2>
00347       inline typename common_type<duration<_Rep1, _Period1>, 
00348                                   duration<_Rep2, _Period2>>::type
00349       operator-(const duration<_Rep1, _Period1>& __lhs, 
00350                 const duration<_Rep2, _Period2>& __rhs)
00351       {
00352         typedef typename common_type<duration<_Rep1, _Period1>,
00353                                      duration<_Rep2, _Period2>>::type __ct;
00354         return __ct(__lhs) -= __rhs;
00355       }
00356 
00357     template<typename _Rep1, typename _Rep2, bool =
00358          is_convertible<_Rep2,
00359                 typename common_type<_Rep1, _Rep2>::type>::value>
00360       struct __common_rep_type { };
00361 
00362     template<typename _Rep1, typename _Rep2>
00363       struct __common_rep_type<_Rep1, _Rep2, true>
00364       { typedef typename common_type<_Rep1, _Rep2>::type type; };     
00365 
00366     template<typename _Rep1, typename _Period, typename _Rep2>
00367       inline duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
00368       operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00369       {
00370         typedef typename common_type<_Rep1, _Rep2>::type __cr;
00371         return duration<__cr, _Period>(__d) *= __s;
00372       }
00373 
00374     template<typename _Rep1, typename _Period, typename _Rep2>
00375       inline duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
00376       operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
00377       { return __d * __s; }
00378  
00379     template<typename _Rep1, typename _Period, typename _Rep2>
00380       inline duration<typename __common_rep_type<_Rep1, typename
00381     enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
00382       operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00383       {
00384     typedef typename common_type<_Rep1, _Rep2>::type __cr;
00385     return duration<__cr, _Period>(__d) /= __s;
00386       }
00387 
00388      template<typename _Rep1, typename _Period1,
00389           typename _Rep2, typename _Period2>
00390       inline typename common_type<_Rep1, _Rep2>::type
00391       operator/(const duration<_Rep1, _Period1>& __lhs, 
00392                 const duration<_Rep2, _Period2>& __rhs)
00393       {
00394         typedef typename common_type<duration<_Rep1, _Period1>, 
00395                                      duration<_Rep2, _Period2>>::type __ct;
00396         return __ct(__lhs).count() / __ct(__rhs).count();
00397       }
00398 
00399     // DR 934.
00400     template<typename _Rep1, typename _Period, typename _Rep2>
00401       inline duration<typename __common_rep_type<_Rep1, typename
00402     enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
00403       operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00404       {
00405     typedef typename common_type<_Rep1, _Rep2>::type __cr;
00406     return duration<__cr, _Period>(__d) %= __s;
00407       }
00408 
00409      template<typename _Rep1, typename _Period1,
00410           typename _Rep2, typename _Period2>
00411       inline typename common_type<duration<_Rep1, _Period1>, 
00412                                   duration<_Rep2, _Period2>>::type
00413       operator%(const duration<_Rep1, _Period1>& __lhs, 
00414                 const duration<_Rep2, _Period2>& __rhs)
00415       {
00416         typedef typename common_type<duration<_Rep1, _Period1>, 
00417                                      duration<_Rep2, _Period2>>::type __ct;
00418         return __ct(__lhs) %= __rhs;
00419       }
00420 
00421     // comparisons
00422     template<typename _Rep1, typename _Period1,
00423              typename _Rep2, typename _Period2>
00424       inline bool
00425       operator==(const duration<_Rep1, _Period1>& __lhs, 
00426                  const duration<_Rep2, _Period2>& __rhs)
00427       {
00428         typedef typename common_type<duration<_Rep1, _Period1>, 
00429                                      duration<_Rep2, _Period2>>::type __ct;
00430         return __ct(__lhs).count() == __ct(__rhs).count();
00431       }
00432 
00433     template<typename _Rep1, typename _Period1,
00434              typename _Rep2, typename _Period2>
00435       inline bool
00436       operator<(const duration<_Rep1, _Period1>& __lhs, 
00437                 const duration<_Rep2, _Period2>& __rhs)
00438       {
00439         typedef typename common_type<duration<_Rep1, _Period1>, 
00440                                      duration<_Rep2, _Period2>>::type __ct;
00441         return __ct(__lhs).count() < __ct(__rhs).count();
00442       }
00443 
00444     template<typename _Rep1, typename _Period1,
00445              typename _Rep2, typename _Period2>
00446       inline bool
00447       operator!=(const duration<_Rep1, _Period1>& __lhs, 
00448                  const duration<_Rep2, _Period2>& __rhs)
00449       { return !(__lhs == __rhs); }
00450 
00451     template<typename _Rep1, typename _Period1,
00452              typename _Rep2, typename _Period2>
00453       inline bool
00454       operator<=(const duration<_Rep1, _Period1>& __lhs, 
00455                  const duration<_Rep2, _Period2>& __rhs)
00456       { return !(__rhs < __lhs); }
00457 
00458     template<typename _Rep1, typename _Period1,
00459              typename _Rep2, typename _Period2>
00460       inline bool 
00461       operator>(const duration<_Rep1, _Period1>& __lhs, 
00462                 const duration<_Rep2, _Period2>& __rhs)
00463       { return __rhs < __lhs; }
00464 
00465     template<typename _Rep1, typename _Period1, 
00466              typename _Rep2, typename _Period2>
00467       inline bool
00468       operator>=(const duration<_Rep1, _Period1>& __lhs, 
00469                  const duration<_Rep2, _Period2>& __rhs)
00470       { return !(__lhs < __rhs); }
00471 
00472     /// nanoseconds
00473     typedef duration<int64_t,        nano> nanoseconds;
00474 
00475     /// microseconds
00476     typedef duration<int64_t,       micro> microseconds;
00477 
00478     /// milliseconds
00479     typedef duration<int64_t,       milli> milliseconds;
00480     
00481     /// seconds
00482     typedef duration<int64_t             > seconds;
00483 
00484     /// minutes
00485     typedef duration<int,     ratio<  60>> minutes;
00486 
00487     /// hours
00488     typedef duration<int,     ratio<3600>> hours;
00489 
00490     /// time_point
00491     template<typename _Clock, typename _Duration>
00492       struct time_point
00493       {
00494     typedef _Clock                    clock;
00495     typedef _Duration                 duration;
00496     typedef typename duration::rep    rep;
00497     typedef typename duration::period period;
00498 
00499     time_point() : __d(duration::zero())
00500     { }
00501 
00502     explicit time_point(const duration& __dur) 
00503     : __d(duration::zero() + __dur)
00504     { }
00505 
00506     // conversions
00507     template<typename _Duration2>
00508       time_point(const time_point<clock, _Duration2>& __t)
00509       : __d(__t.time_since_epoch())
00510       { }
00511 
00512     // observer
00513     duration
00514     time_since_epoch() const
00515     { return __d; }
00516     
00517     // arithmetic
00518     time_point&
00519     operator+=(const duration& __dur)
00520     {
00521       __d += __dur;
00522       return *this;
00523     }
00524     
00525     time_point&
00526     operator-=(const duration& __dur)
00527     {
00528       __d -= __dur;
00529       return *this;
00530     }
00531     
00532     // special values
00533     // TODO: These should be constexprs.
00534     static const time_point
00535     min()
00536     { return time_point(duration::min()); }
00537     
00538     static const time_point
00539     max()
00540     { return time_point(duration::max()); }
00541     
00542       private:
00543     duration __d;
00544       };
00545   
00546     /// time_point_cast
00547     template<typename _ToDuration, typename _Clock, typename _Duration>
00548       inline typename enable_if<__is_duration<_ToDuration>::value,
00549                 time_point<_Clock, _ToDuration>>::type
00550       time_point_cast(const time_point<_Clock, _Duration>& __t)
00551       {
00552         return time_point<_Clock, _ToDuration>(
00553           duration_cast<_ToDuration>(__t.time_since_epoch()));  
00554       }
00555 
00556     template<typename _Clock, typename _Duration1,
00557              typename _Rep2, typename _Period2>
00558       inline time_point<_Clock, 
00559         typename common_type<_Duration1, duration<_Rep2, _Period2>>::type>
00560       operator+(const time_point<_Clock, _Duration1>& __lhs, 
00561                 const duration<_Rep2, _Period2>& __rhs)
00562       {
00563         typedef time_point<_Clock, 
00564           typename common_type<_Duration1, 
00565                                duration<_Rep2, _Period2>>::type> __ct;
00566         return __ct(__lhs) += __rhs;
00567       }
00568 
00569     template<typename _Rep1, typename _Period1,
00570              typename _Clock, typename _Duration2>
00571       inline time_point<_Clock, 
00572         typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
00573       operator+(const duration<_Rep1, _Period1>& __lhs, 
00574                 const time_point<_Clock, _Duration2>& __rhs)
00575       { return __rhs + __lhs; }
00576 
00577     template<typename _Clock, typename _Duration1,
00578              typename _Rep2, typename _Period2>
00579       inline time_point<_Clock, 
00580         typename common_type<_Duration1, duration<_Rep2, _Period2>>::type>
00581       operator-(const time_point<_Clock, _Duration1>& __lhs, 
00582                 const duration<_Rep2, _Period2>& __rhs)
00583       { return __lhs + (-__rhs); }
00584 
00585     template<typename _Clock, typename _Duration1, typename _Duration2>
00586       inline typename common_type<_Duration1, _Duration2>::type
00587       operator-(const time_point<_Clock, _Duration1>& __lhs, 
00588                 const time_point<_Clock, _Duration2>& __rhs)
00589       { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
00590 
00591     template<typename _Clock, typename _Duration1, typename _Duration2>
00592       inline bool
00593       operator==(const time_point<_Clock, _Duration1>& __lhs,
00594                  const time_point<_Clock, _Duration2>& __rhs)
00595       { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
00596 
00597     template<typename _Clock, typename _Duration1, typename _Duration2>
00598       inline bool
00599       operator!=(const time_point<_Clock, _Duration1>& __lhs,
00600                  const time_point<_Clock, _Duration2>& __rhs)
00601       { return !(__lhs == __rhs); }
00602 
00603     template<typename _Clock, typename _Duration1, typename _Duration2>
00604       inline bool
00605       operator<(const time_point<_Clock, _Duration1>& __lhs,
00606                 const time_point<_Clock, _Duration2>& __rhs)
00607       { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
00608 
00609     template<typename _Clock, typename _Duration1, typename _Duration2>
00610       inline bool
00611       operator<=(const time_point<_Clock, _Duration1>& __lhs,
00612                  const time_point<_Clock, _Duration2>& __rhs)
00613       { return !(__rhs < __lhs); }
00614 
00615     template<typename _Clock, typename _Duration1, typename _Duration2>
00616       inline bool
00617       operator>(const time_point<_Clock, _Duration1>& __lhs,
00618                 const time_point<_Clock, _Duration2>& __rhs)
00619       { return __rhs < __lhs; }
00620 
00621     template<typename _Clock, typename _Duration1, typename _Duration2>
00622       inline bool
00623       operator>=(const time_point<_Clock, _Duration1>& __lhs,
00624                  const time_point<_Clock, _Duration2>& __rhs)
00625       { return !(__lhs < __rhs); }
00626 
00627     /// system_clock
00628     struct system_clock
00629     {
00630 #ifdef _GLIBCXX_USE_CLOCK_REALTIME
00631       typedef chrono::nanoseconds     duration;      
00632 #elif defined(_GLIBCXX_USE_GETTIMEOFDAY)
00633       typedef chrono::microseconds    duration;      
00634 #else
00635       typedef chrono::seconds         duration;      
00636 #endif
00637 
00638       typedef duration::rep    rep;
00639       typedef duration::period period;
00640       typedef chrono::time_point<system_clock, duration> time_point;
00641 
00642       static const bool is_monotonic = false;
00643 
00644       static time_point
00645       now() throw ();
00646 
00647       // Map to C API
00648       static std::time_t
00649       to_time_t(const time_point& __t)
00650       {
00651         return std::time_t(
00652           duration_cast<chrono::seconds>(__t.time_since_epoch()).count());
00653       }
00654 
00655       static time_point
00656       from_time_t(std::time_t __t)
00657       { 
00658         return time_point_cast<system_clock::duration>(
00659           chrono::time_point<system_clock, chrono::seconds>(
00660             chrono::seconds(__t)));
00661       }
00662 
00663       // TODO: requires constexpr
00664       /*  
00665       static_assert(
00666         system_clock::duration::min() < 
00667         system_clock::duration::zero(), 
00668         "a clock's minimum duration cannot be less than its epoch");
00669       */
00670     };
00671 
00672 #ifdef _GLIBCXX_USE_CLOCK_MONOTONIC
00673     /// monotonic_clock
00674     struct monotonic_clock
00675     {
00676       typedef chrono::nanoseconds duration;
00677       typedef duration::rep       rep;
00678       typedef duration::period    period;
00679       typedef chrono::time_point<monotonic_clock, duration> time_point;
00680 
00681       static const bool is_monotonic = true;
00682 
00683       static time_point
00684       now();
00685     };
00686 #else
00687     typedef system_clock monotonic_clock;
00688 #endif
00689 
00690     typedef system_clock high_resolution_clock;
00691   } // namespace chrono
00692 
00693   // @} group chrono
00694 } // namespace std
00695 
00696 #endif //_GLIBCXX_USE_C99_STDINT_TR1
00697 
00698 #endif //__GXX_EXPERIMENTAL_CXX0X__
00699 
00700 #endif //_GLIBCXX_CHRONO