libstdc++
chrono
Go to the documentation of this file.
00001 // <chrono> -*- C++ -*-
00002 
00003 // Copyright (C) 2008-2014 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 #if __cplusplus < 201103L
00035 # include <bits/c++0x_warning.h>
00036 #else
00037 
00038 #include <ratio>
00039 #include <type_traits>
00040 #include <limits>
00041 #include <ctime>
00042 #include <bits/parse_numbers.h> // for literals support.
00043 
00044 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
00045 
00046 namespace std _GLIBCXX_VISIBILITY(default)
00047 {
00048   /**
00049    * @defgroup chrono Time
00050    * @ingroup utilities
00051    *
00052    * Classes and functions for time.
00053    * @{
00054    */
00055 
00056   /** @namespace std::chrono
00057    *  @brief ISO C++ 2011 entities sub-namespace for time and date.
00058    */
00059   namespace chrono
00060   {
00061   _GLIBCXX_BEGIN_NAMESPACE_VERSION
00062 
00063     template<typename _Rep, typename _Period = ratio<1>>
00064       struct duration;
00065 
00066     template<typename _Clock, typename _Dur = typename _Clock::duration>
00067       struct time_point;
00068 
00069   _GLIBCXX_END_NAMESPACE_VERSION
00070   }
00071 
00072 _GLIBCXX_BEGIN_NAMESPACE_VERSION
00073 
00074   // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
00075   
00076   template<typename _CT, typename _Period1, typename _Period2>
00077     struct __duration_common_type_wrapper
00078     {
00079     private:
00080       typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
00081       typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
00082       typedef typename _CT::type __cr;
00083       typedef ratio<__gcd_num::value,
00084         (_Period1::den / __gcd_den::value) * _Period2::den> __r;
00085     public:
00086       typedef __success_type<chrono::duration<__cr, __r>> type;
00087     };
00088 
00089   template<typename _Period1, typename _Period2>
00090     struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
00091     { typedef __failure_type type; };
00092 
00093   template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
00094     struct common_type<chrono::duration<_Rep1, _Period1>,
00095              chrono::duration<_Rep2, _Period2>>
00096     : public __duration_common_type_wrapper<typename __member_type_wrapper<
00097              common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
00098     { };
00099 
00100   // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
00101   
00102   template<typename _CT, typename _Clock>
00103     struct __timepoint_common_type_wrapper
00104     {
00105       typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
00106         type;
00107     };
00108 
00109   template<typename _Clock>
00110     struct __timepoint_common_type_wrapper<__failure_type, _Clock>
00111     { typedef __failure_type type; };
00112 
00113   template<typename _Clock, typename _Duration1, typename _Duration2>
00114     struct common_type<chrono::time_point<_Clock, _Duration1>,
00115              chrono::time_point<_Clock, _Duration2>>
00116     : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
00117              common_type<_Duration1, _Duration2>>::type, _Clock>::type
00118     { };
00119 
00120 _GLIBCXX_END_NAMESPACE_VERSION
00121 
00122   namespace chrono
00123   {
00124   _GLIBCXX_BEGIN_NAMESPACE_VERSION
00125 
00126     // Primary template for duration_cast impl.
00127     template<typename _ToDur, typename _CF, typename _CR,
00128          bool _NumIsOne = false, bool _DenIsOne = false>
00129       struct __duration_cast_impl
00130       {
00131     template<typename _Rep, typename _Period>
00132       static constexpr _ToDur
00133       __cast(const duration<_Rep, _Period>& __d)
00134       {
00135         typedef typename _ToDur::rep            __to_rep;
00136         return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
00137           * static_cast<_CR>(_CF::num)
00138           / static_cast<_CR>(_CF::den)));
00139       }
00140       };
00141 
00142     template<typename _ToDur, typename _CF, typename _CR>
00143       struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
00144       {
00145     template<typename _Rep, typename _Period>
00146       static constexpr _ToDur
00147       __cast(const duration<_Rep, _Period>& __d)
00148       {
00149         typedef typename _ToDur::rep            __to_rep;
00150         return _ToDur(static_cast<__to_rep>(__d.count()));
00151       }
00152       };
00153 
00154     template<typename _ToDur, typename _CF, typename _CR>
00155       struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
00156       {
00157     template<typename _Rep, typename _Period>
00158       static constexpr _ToDur
00159       __cast(const duration<_Rep, _Period>& __d)
00160       {
00161         typedef typename _ToDur::rep            __to_rep;
00162         return _ToDur(static_cast<__to_rep>(
00163           static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
00164       }
00165       };
00166 
00167     template<typename _ToDur, typename _CF, typename _CR>
00168       struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
00169       {
00170     template<typename _Rep, typename _Period>
00171       static constexpr _ToDur
00172       __cast(const duration<_Rep, _Period>& __d)
00173       {
00174         typedef typename _ToDur::rep            __to_rep;
00175         return _ToDur(static_cast<__to_rep>(
00176           static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
00177       }
00178       };
00179 
00180     template<typename _Tp>
00181       struct __is_duration
00182       : std::false_type
00183       { };
00184 
00185     template<typename _Rep, typename _Period>
00186       struct __is_duration<duration<_Rep, _Period>>
00187       : std::true_type
00188       { };
00189 
00190     /// duration_cast
00191     template<typename _ToDur, typename _Rep, typename _Period>
00192       constexpr typename enable_if<__is_duration<_ToDur>::value,
00193                    _ToDur>::type
00194       duration_cast(const duration<_Rep, _Period>& __d)
00195       {
00196     typedef typename _ToDur::period             __to_period;
00197     typedef typename _ToDur::rep                __to_rep;
00198     typedef ratio_divide<_Period, __to_period>      __cf;
00199     typedef typename common_type<__to_rep, _Rep, intmax_t>::type
00200                                 __cr;
00201     typedef  __duration_cast_impl<_ToDur, __cf, __cr,
00202                       __cf::num == 1, __cf::den == 1> __dc;
00203     return __dc::__cast(__d);
00204       }
00205 
00206     /// treat_as_floating_point
00207     template<typename _Rep>
00208       struct treat_as_floating_point
00209       : is_floating_point<_Rep>
00210       { };
00211 
00212     /// duration_values
00213     template<typename _Rep>
00214       struct duration_values
00215       {
00216     static constexpr _Rep
00217     zero()
00218     { return _Rep(0); }
00219 
00220     static constexpr _Rep
00221     max()
00222     { return numeric_limits<_Rep>::max(); }
00223 
00224     static constexpr _Rep
00225     min()
00226     { return numeric_limits<_Rep>::lowest(); }
00227       };
00228 
00229     template<typename _Tp>
00230       struct __is_ratio
00231       : std::false_type
00232       { };
00233 
00234     template<intmax_t _Num, intmax_t _Den>
00235       struct __is_ratio<ratio<_Num, _Den>>
00236       : std::true_type
00237       { };
00238 
00239     /// duration
00240     template<typename _Rep, typename _Period>
00241       struct duration
00242       {
00243     typedef _Rep                        rep;
00244     typedef _Period                     period;
00245 
00246     static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
00247     static_assert(__is_ratio<_Period>::value,
00248               "period must be a specialization of ratio");
00249     static_assert(_Period::num > 0, "period must be positive");
00250 
00251     // 20.11.5.1 construction / copy / destroy
00252     constexpr duration() = default;
00253 
00254     // NB: Make constexpr implicit. This cannot be explicitly
00255     // constexpr, as any UDT that is not a literal type with a
00256     // constexpr copy constructor will be ill-formed.
00257     duration(const duration&) = default;
00258 
00259     template<typename _Rep2, typename = typename
00260            enable_if<is_convertible<_Rep2, rep>::value
00261              && (treat_as_floating_point<rep>::value
00262                  || !treat_as_floating_point<_Rep2>::value)>::type>
00263       constexpr explicit duration(const _Rep2& __rep)
00264       : __r(static_cast<rep>(__rep)) { }
00265 
00266     template<typename _Rep2, typename _Period2, typename = typename
00267            enable_if<treat_as_floating_point<rep>::value
00268              || (ratio_divide<_Period2, period>::den == 1
00269                  && !treat_as_floating_point<_Rep2>::value)>::type>
00270       constexpr duration(const duration<_Rep2, _Period2>& __d)
00271       : __r(duration_cast<duration>(__d).count()) { }
00272 
00273     ~duration() = default;
00274     duration& operator=(const duration&) = default;
00275 
00276     // 20.11.5.2 observer
00277     constexpr rep
00278     count() const
00279     { return __r; }
00280 
00281     // 20.11.5.3 arithmetic
00282     constexpr duration
00283     operator+() const
00284     { return *this; }
00285 
00286     constexpr duration
00287     operator-() const
00288     { return duration(-__r); }
00289 
00290     duration&
00291     operator++()
00292     {
00293       ++__r;
00294       return *this;
00295     }
00296 
00297     duration
00298     operator++(int)
00299     { return duration(__r++); }
00300 
00301     duration&
00302     operator--()
00303     {
00304       --__r;
00305       return *this;
00306     }
00307 
00308     duration
00309     operator--(int)
00310     { return duration(__r--); }
00311 
00312     duration&
00313     operator+=(const duration& __d)
00314     {
00315       __r += __d.count();
00316       return *this;
00317     }
00318 
00319     duration&
00320     operator-=(const duration& __d)
00321     {
00322       __r -= __d.count();
00323       return *this;
00324     }
00325 
00326     duration&
00327     operator*=(const rep& __rhs)
00328     {
00329       __r *= __rhs;
00330       return *this;
00331     }
00332 
00333     duration&
00334     operator/=(const rep& __rhs)
00335     {
00336       __r /= __rhs;
00337       return *this;
00338     }
00339 
00340     // DR 934.
00341     template<typename _Rep2 = rep>
00342       typename enable_if<!treat_as_floating_point<_Rep2>::value,
00343                  duration&>::type
00344       operator%=(const rep& __rhs)
00345       {
00346         __r %= __rhs;
00347         return *this;
00348       }
00349 
00350     template<typename _Rep2 = rep>
00351       typename enable_if<!treat_as_floating_point<_Rep2>::value,
00352                  duration&>::type
00353       operator%=(const duration& __d)
00354       {
00355         __r %= __d.count();
00356         return *this;
00357       }
00358 
00359     // 20.11.5.4 special values
00360     static constexpr duration
00361     zero()
00362     { return duration(duration_values<rep>::zero()); }
00363 
00364     static constexpr duration
00365     min()
00366     { return duration(duration_values<rep>::min()); }
00367 
00368     static constexpr duration
00369     max()
00370     { return duration(duration_values<rep>::max()); }
00371 
00372       private:
00373     rep __r;
00374       };
00375 
00376     template<typename _Rep1, typename _Period1,
00377          typename _Rep2, typename _Period2>
00378       constexpr typename common_type<duration<_Rep1, _Period1>,
00379                      duration<_Rep2, _Period2>>::type
00380       operator+(const duration<_Rep1, _Period1>& __lhs,
00381         const duration<_Rep2, _Period2>& __rhs)
00382       {
00383     typedef duration<_Rep1, _Period1>           __dur1;
00384     typedef duration<_Rep2, _Period2>           __dur2;
00385     typedef typename common_type<__dur1,__dur2>::type   __cd;
00386     return __cd(__cd(__lhs).count() + __cd(__rhs).count());
00387       }
00388 
00389     template<typename _Rep1, typename _Period1,
00390          typename _Rep2, typename _Period2>
00391       constexpr typename common_type<duration<_Rep1, _Period1>,
00392                      duration<_Rep2, _Period2>>::type
00393       operator-(const duration<_Rep1, _Period1>& __lhs,
00394         const duration<_Rep2, _Period2>& __rhs)
00395       {
00396     typedef duration<_Rep1, _Period1>           __dur1;
00397     typedef duration<_Rep2, _Period2>           __dur2;
00398     typedef typename common_type<__dur1,__dur2>::type   __cd;
00399     return __cd(__cd(__lhs).count() - __cd(__rhs).count());
00400       }
00401 
00402     template<typename _Rep1, typename _Rep2, bool =
00403          is_convertible<_Rep2,
00404                 typename common_type<_Rep1, _Rep2>::type>::value>
00405       struct __common_rep_type { };
00406 
00407     template<typename _Rep1, typename _Rep2>
00408       struct __common_rep_type<_Rep1, _Rep2, true>
00409       { typedef typename common_type<_Rep1, _Rep2>::type type; };
00410 
00411     template<typename _Rep1, typename _Period, typename _Rep2>
00412       constexpr
00413       duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
00414       operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00415       {
00416     typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
00417       __cd;
00418     return __cd(__cd(__d).count() * __s);
00419       }
00420 
00421     template<typename _Rep1, typename _Rep2, typename _Period>
00422       constexpr
00423       duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
00424       operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
00425       { return __d * __s; }
00426 
00427     template<typename _Rep1, typename _Period, typename _Rep2>
00428       constexpr duration<typename __common_rep_type<_Rep1, typename
00429     enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
00430       operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00431       {
00432     typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
00433       __cd;
00434     return __cd(__cd(__d).count() / __s);
00435       }
00436 
00437     template<typename _Rep1, typename _Period1,
00438          typename _Rep2, typename _Period2>
00439       constexpr typename common_type<_Rep1, _Rep2>::type
00440       operator/(const duration<_Rep1, _Period1>& __lhs,
00441         const duration<_Rep2, _Period2>& __rhs)
00442       {
00443     typedef duration<_Rep1, _Period1>           __dur1;
00444     typedef duration<_Rep2, _Period2>           __dur2;
00445     typedef typename common_type<__dur1,__dur2>::type   __cd;
00446     return __cd(__lhs).count() / __cd(__rhs).count();
00447       }
00448 
00449     // DR 934.
00450     template<typename _Rep1, typename _Period, typename _Rep2>
00451       constexpr duration<typename __common_rep_type<_Rep1, typename
00452     enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
00453       operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
00454       {
00455     typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
00456       __cd;
00457     return __cd(__cd(__d).count() % __s);
00458       }
00459 
00460     template<typename _Rep1, typename _Period1,
00461          typename _Rep2, typename _Period2>
00462       constexpr typename common_type<duration<_Rep1, _Period1>,
00463                      duration<_Rep2, _Period2>>::type
00464       operator%(const duration<_Rep1, _Period1>& __lhs,
00465         const duration<_Rep2, _Period2>& __rhs)
00466       {
00467     typedef duration<_Rep1, _Period1>           __dur1;
00468     typedef duration<_Rep2, _Period2>           __dur2;
00469     typedef typename common_type<__dur1,__dur2>::type   __cd;
00470     return __cd(__cd(__lhs).count() % __cd(__rhs).count());
00471       }
00472 
00473     // comparisons
00474     template<typename _Rep1, typename _Period1,
00475          typename _Rep2, typename _Period2>
00476       constexpr bool
00477       operator==(const duration<_Rep1, _Period1>& __lhs,
00478          const duration<_Rep2, _Period2>& __rhs)
00479       {
00480     typedef duration<_Rep1, _Period1>           __dur1;
00481     typedef duration<_Rep2, _Period2>           __dur2;
00482     typedef typename common_type<__dur1,__dur2>::type   __ct;
00483     return __ct(__lhs).count() == __ct(__rhs).count();
00484       }
00485 
00486     template<typename _Rep1, typename _Period1,
00487          typename _Rep2, typename _Period2>
00488       constexpr bool
00489       operator<(const duration<_Rep1, _Period1>& __lhs,
00490         const duration<_Rep2, _Period2>& __rhs)
00491       {
00492     typedef duration<_Rep1, _Period1>           __dur1;
00493     typedef duration<_Rep2, _Period2>           __dur2;
00494     typedef typename common_type<__dur1,__dur2>::type   __ct;
00495     return __ct(__lhs).count() < __ct(__rhs).count();
00496       }
00497 
00498     template<typename _Rep1, typename _Period1,
00499          typename _Rep2, typename _Period2>
00500       constexpr bool
00501       operator!=(const duration<_Rep1, _Period1>& __lhs,
00502          const duration<_Rep2, _Period2>& __rhs)
00503       { return !(__lhs == __rhs); }
00504 
00505     template<typename _Rep1, typename _Period1,
00506          typename _Rep2, typename _Period2>
00507       constexpr bool
00508       operator<=(const duration<_Rep1, _Period1>& __lhs,
00509          const duration<_Rep2, _Period2>& __rhs)
00510       { return !(__rhs < __lhs); }
00511 
00512     template<typename _Rep1, typename _Period1,
00513          typename _Rep2, typename _Period2>
00514       constexpr bool
00515       operator>(const duration<_Rep1, _Period1>& __lhs,
00516         const duration<_Rep2, _Period2>& __rhs)
00517       { return __rhs < __lhs; }
00518 
00519     template<typename _Rep1, typename _Period1,
00520          typename _Rep2, typename _Period2>
00521       constexpr bool
00522       operator>=(const duration<_Rep1, _Period1>& __lhs,
00523          const duration<_Rep2, _Period2>& __rhs)
00524       { return !(__lhs < __rhs); }
00525 
00526     /// nanoseconds
00527     typedef duration<int64_t, nano>         nanoseconds;
00528 
00529     /// microseconds
00530     typedef duration<int64_t, micro>        microseconds;
00531 
00532     /// milliseconds
00533     typedef duration<int64_t, milli>        milliseconds;
00534 
00535     /// seconds
00536     typedef duration<int64_t>           seconds;
00537 
00538     /// minutes
00539     typedef duration<int64_t, ratio< 60>>   minutes;
00540 
00541     /// hours
00542     typedef duration<int64_t, ratio<3600>>  hours;
00543 
00544     /// time_point
00545     template<typename _Clock, typename _Dur>
00546       struct time_point
00547       {
00548     typedef _Clock                      clock;
00549     typedef _Dur                        duration;
00550     typedef typename duration::rep              rep;
00551     typedef typename duration::period           period;
00552 
00553     constexpr time_point() : __d(duration::zero())
00554     { }
00555 
00556     constexpr explicit time_point(const duration& __dur)
00557     : __d(__dur)
00558     { }
00559 
00560     // conversions
00561     template<typename _Dur2>
00562       constexpr time_point(const time_point<clock, _Dur2>& __t)
00563       : __d(__t.time_since_epoch())
00564       { }
00565 
00566     // observer
00567     constexpr duration
00568     time_since_epoch() const
00569     { return __d; }
00570 
00571     // arithmetic
00572     time_point&
00573     operator+=(const duration& __dur)
00574     {
00575       __d += __dur;
00576       return *this;
00577     }
00578 
00579     time_point&
00580     operator-=(const duration& __dur)
00581     {
00582       __d -= __dur;
00583       return *this;
00584     }
00585 
00586     // special values
00587     static constexpr time_point
00588     min()
00589     { return time_point(duration::min()); }
00590 
00591     static constexpr time_point
00592     max()
00593     { return time_point(duration::max()); }
00594 
00595       private:
00596     duration __d;
00597       };
00598 
00599     /// time_point_cast
00600     template<typename _ToDur, typename _Clock, typename _Dur>
00601       constexpr typename enable_if<__is_duration<_ToDur>::value,
00602                    time_point<_Clock, _ToDur>>::type
00603       time_point_cast(const time_point<_Clock, _Dur>& __t)
00604       {
00605     typedef time_point<_Clock, _ToDur>          __time_point;
00606     return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
00607       }
00608 
00609     template<typename _Clock, typename _Dur1,
00610          typename _Rep2, typename _Period2>
00611       constexpr time_point<_Clock,
00612     typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
00613       operator+(const time_point<_Clock, _Dur1>& __lhs,
00614         const duration<_Rep2, _Period2>& __rhs)
00615       {
00616     typedef duration<_Rep2, _Period2>           __dur2;
00617     typedef typename common_type<_Dur1,__dur2>::type    __ct;
00618     typedef time_point<_Clock, __ct>            __time_point;
00619     return __time_point(__lhs.time_since_epoch() + __rhs);
00620       }
00621 
00622     template<typename _Rep1, typename _Period1,
00623          typename _Clock, typename _Dur2>
00624       constexpr time_point<_Clock,
00625     typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
00626       operator+(const duration<_Rep1, _Period1>& __lhs,
00627         const time_point<_Clock, _Dur2>& __rhs)
00628       { 
00629     typedef duration<_Rep1, _Period1>           __dur1;
00630     typedef typename common_type<__dur1,_Dur2>::type    __ct;
00631     typedef time_point<_Clock, __ct>            __time_point;
00632     return __time_point(__rhs.time_since_epoch() + __lhs); 
00633       }
00634 
00635     template<typename _Clock, typename _Dur1,
00636          typename _Rep2, typename _Period2>
00637       constexpr time_point<_Clock,
00638     typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
00639       operator-(const time_point<_Clock, _Dur1>& __lhs,
00640         const duration<_Rep2, _Period2>& __rhs)
00641       { 
00642     typedef duration<_Rep2, _Period2>           __dur2;
00643     typedef typename common_type<_Dur1,__dur2>::type    __ct;
00644     typedef time_point<_Clock, __ct>            __time_point;
00645     return __time_point(__lhs.time_since_epoch() -__rhs); 
00646       }
00647 
00648     template<typename _Clock, typename _Dur1, typename _Dur2>
00649       constexpr typename common_type<_Dur1, _Dur2>::type
00650       operator-(const time_point<_Clock, _Dur1>& __lhs,
00651         const time_point<_Clock, _Dur2>& __rhs)
00652       { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
00653 
00654     template<typename _Clock, typename _Dur1, typename _Dur2>
00655       constexpr bool
00656       operator==(const time_point<_Clock, _Dur1>& __lhs,
00657          const time_point<_Clock, _Dur2>& __rhs)
00658       { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
00659 
00660     template<typename _Clock, typename _Dur1, typename _Dur2>
00661       constexpr bool
00662       operator!=(const time_point<_Clock, _Dur1>& __lhs,
00663          const time_point<_Clock, _Dur2>& __rhs)
00664       { return !(__lhs == __rhs); }
00665 
00666     template<typename _Clock, typename _Dur1, typename _Dur2>
00667       constexpr bool
00668       operator<(const time_point<_Clock, _Dur1>& __lhs,
00669         const time_point<_Clock, _Dur2>& __rhs)
00670       { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
00671 
00672     template<typename _Clock, typename _Dur1, typename _Dur2>
00673       constexpr bool
00674       operator<=(const time_point<_Clock, _Dur1>& __lhs,
00675          const time_point<_Clock, _Dur2>& __rhs)
00676       { return !(__rhs < __lhs); }
00677 
00678     template<typename _Clock, typename _Dur1, typename _Dur2>
00679       constexpr bool
00680       operator>(const time_point<_Clock, _Dur1>& __lhs,
00681         const time_point<_Clock, _Dur2>& __rhs)
00682       { return __rhs < __lhs; }
00683 
00684     template<typename _Clock, typename _Dur1, typename _Dur2>
00685       constexpr bool
00686       operator>=(const time_point<_Clock, _Dur1>& __lhs,
00687          const time_point<_Clock, _Dur2>& __rhs)
00688       { return !(__lhs < __rhs); }
00689 
00690 
00691     // Clocks. 
00692 
00693     // Why nanosecond resolution as the default?  
00694     // Why have std::system_clock always count in the higest
00695     // resolution (ie nanoseconds), even if on some OSes the low 3
00696     // or 9 decimal digits will be always zero? This allows later
00697     // implementations to change the system_clock::now()
00698     // implementation any time to provide better resolution without
00699     // changing function signature or units.
00700 
00701     // To support the (forward) evolution of the library's defined
00702     // clocks, wrap inside inline namespace so that the current
00703     // defintions of system_clock, steady_clock, and
00704     // high_resolution_clock types are uniquely mangled. This way, new
00705     // code can use the latests clocks, while the library can contain
00706     // compatibility definitions for previous versions.  At some
00707     // point, when these clocks settle down, the inlined namespaces
00708     // can be removed.  XXX GLIBCXX_ABI Deprecated
00709     inline namespace _V2 {
00710 
00711     /**
00712      *  @brief System clock.
00713      *
00714      *  Time returned represents wall time from the system-wide clock.
00715     */
00716     struct system_clock
00717     {
00718       typedef chrono::nanoseconds                   duration;
00719       typedef duration::rep                     rep;
00720       typedef duration::period                  period;
00721       typedef chrono::time_point<system_clock, duration>    time_point;
00722 
00723       static_assert(system_clock::duration::min()
00724             < system_clock::duration::zero(),
00725             "a clock's minimum duration cannot be less than its epoch");
00726 
00727       static constexpr bool is_steady = false;
00728 
00729       static time_point
00730       now() noexcept;
00731 
00732       // Map to C API
00733       static std::time_t
00734       to_time_t(const time_point& __t) noexcept
00735       {
00736     return std::time_t(duration_cast<chrono::seconds>
00737                (__t.time_since_epoch()).count());
00738       }
00739 
00740       static time_point
00741       from_time_t(std::time_t __t) noexcept
00742       {
00743     typedef chrono::time_point<system_clock, seconds>   __from;
00744     return time_point_cast<system_clock::duration>
00745            (__from(chrono::seconds(__t)));
00746       }
00747     };
00748 
00749 
00750     /**
00751      *  @brief Monotonic clock
00752      *
00753      *  Time returned has the property of only increasing at a uniform rate.
00754     */
00755     struct steady_clock
00756     {
00757       typedef chrono::nanoseconds               duration;
00758       typedef duration::rep                 rep;
00759       typedef duration::period                  period;
00760       typedef chrono::time_point<steady_clock, duration>    time_point;
00761 
00762       static constexpr bool is_steady = true;
00763 
00764       static time_point
00765       now() noexcept;
00766     };
00767 
00768 
00769     /**
00770      *  @brief Highest-resolution clock
00771      *
00772      *  This is the clock "with the shortest tick period." Alias to
00773      *  std::system_clock until higher-than-nanosecond definitions
00774      *  become feasible.
00775     */
00776     using high_resolution_clock = system_clock;
00777 
00778     } // end inline namespace _V2
00779 
00780   _GLIBCXX_END_NAMESPACE_VERSION
00781   } // namespace chrono
00782 
00783 #if __cplusplus > 201103L
00784 
00785   inline namespace literals
00786   {
00787   inline namespace chrono_literals
00788   {
00789 
00790     namespace __select_type
00791     {
00792 
00793       using namespace __parse_int;
00794 
00795       template<unsigned long long _Val, typename _Dur>
00796     struct _Select_type
00797     : conditional<
00798         _Val <= static_cast<unsigned long long>
00799               (numeric_limits<typename _Dur::rep>::max()),
00800         _Dur, void>
00801     {
00802       static constexpr typename _Select_type::type
00803         value{static_cast<typename _Select_type::type>(_Val)};
00804     };
00805 
00806       template<unsigned long long _Val, typename _Dur>
00807     constexpr typename _Select_type<_Val, _Dur>::type
00808     _Select_type<_Val, _Dur>::value;
00809 
00810     } // __select_type
00811 
00812     constexpr chrono::duration<long double, ratio<3600,1>>
00813     operator""h(long double __hours)
00814     { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
00815 
00816     template <char... _Digits>
00817       constexpr typename
00818       __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
00819                  chrono::hours>::type
00820       operator""h()
00821       {
00822     return __select_type::_Select_type<
00823               __select_int::_Select_int<_Digits...>::value,
00824               chrono::hours>::value;
00825       }
00826 
00827     constexpr chrono::duration<long double, ratio<60,1>>
00828     operator""min(long double __mins)
00829     { return chrono::duration<long double, ratio<60,1>>{__mins}; }
00830 
00831     template <char... _Digits>
00832       constexpr typename
00833       __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
00834                  chrono::minutes>::type
00835       operator""min()
00836       {
00837     return __select_type::_Select_type<
00838               __select_int::_Select_int<_Digits...>::value,
00839               chrono::minutes>::value;
00840       }
00841 
00842     constexpr chrono::duration<long double>
00843     operator""s(long double __secs)
00844     { return chrono::duration<long double>{__secs}; }
00845 
00846     template <char... _Digits>
00847       constexpr typename
00848       __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
00849                  chrono::seconds>::type
00850       operator""s()
00851       {
00852     return __select_type::_Select_type<
00853               __select_int::_Select_int<_Digits...>::value,
00854               chrono::seconds>::value;
00855       }
00856 
00857     constexpr chrono::duration<long double, milli>
00858     operator""ms(long double __msecs)
00859     { return chrono::duration<long double, milli>{__msecs}; }
00860 
00861     template <char... _Digits>
00862       constexpr typename
00863       __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
00864                  chrono::milliseconds>::type
00865       operator""ms()
00866       {
00867     return __select_type::_Select_type<
00868               __select_int::_Select_int<_Digits...>::value,
00869               chrono::milliseconds>::value;
00870       }
00871 
00872     constexpr chrono::duration<long double, micro>
00873     operator""us(long double __usecs)
00874     { return chrono::duration<long double, micro>{__usecs}; }
00875 
00876     template <char... _Digits>
00877       constexpr typename
00878       __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
00879                  chrono::microseconds>::type
00880       operator""us()
00881       {
00882     return __select_type::_Select_type<
00883               __select_int::_Select_int<_Digits...>::value,
00884               chrono::microseconds>::value;
00885       }
00886 
00887     constexpr chrono::duration<long double, nano>
00888     operator""ns(long double __nsecs)
00889     { return chrono::duration<long double, nano>{__nsecs}; }
00890 
00891     template <char... _Digits>
00892       constexpr typename
00893       __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value,
00894                  chrono::nanoseconds>::type
00895       operator""ns()
00896       {
00897     return __select_type::_Select_type<
00898               __select_int::_Select_int<_Digits...>::value,
00899               chrono::nanoseconds>::value;
00900       }
00901 
00902   } // inline namespace chrono_literals
00903   } // inline namespace literals
00904 
00905 #endif // __cplusplus > 201103L
00906 
00907   // @} group chrono
00908 } // namespace std
00909 
00910 #endif //_GLIBCXX_USE_C99_STDINT_TR1
00911 
00912 #endif // C++11
00913 
00914 #endif //_GLIBCXX_CHRONO