Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. // <chrono> -*- C++ -*-
  2.  
  3. // Copyright (C) 2008-2013 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. #if __cplusplus < 201103L
  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. namespace 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++ 2011 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.  
  73.   // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
  74.  
  75.   template<typename _CT, typename _Period1, typename _Period2>
  76.     struct __duration_common_type_wrapper
  77.     {
  78.     private:
  79.       typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
  80.       typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
  81.       typedef typename _CT::type __cr;
  82.       typedef ratio<__gcd_num::value,
  83.         (_Period1::den / __gcd_den::value) * _Period2::den> __r;
  84.     public:
  85.       typedef __success_type<chrono::duration<__cr, __r>> type;
  86.     };
  87.  
  88.   template<typename _Period1, typename _Period2>
  89.     struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
  90.     { typedef __failure_type type; };
  91.  
  92.   template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
  93.     struct common_type<chrono::duration<_Rep1, _Period1>,
  94.              chrono::duration<_Rep2, _Period2>>
  95.     : public __duration_common_type_wrapper<typename __member_type_wrapper<
  96.              common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
  97.     { };
  98.  
  99.   // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
  100.  
  101.   template<typename _CT, typename _Clock>
  102.     struct __timepoint_common_type_wrapper
  103.     {
  104.       typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
  105.         type;
  106.     };
  107.  
  108.   template<typename _Clock>
  109.     struct __timepoint_common_type_wrapper<__failure_type, _Clock>
  110.     { typedef __failure_type type; };
  111.  
  112.   template<typename _Clock, typename _Duration1, typename _Duration2>
  113.     struct common_type<chrono::time_point<_Clock, _Duration1>,
  114.              chrono::time_point<_Clock, _Duration2>>
  115.     : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
  116.              common_type<_Duration1, _Duration2>>::type, _Clock>::type
  117.     { };
  118.  
  119. _GLIBCXX_END_NAMESPACE_VERSION
  120.  
  121.   namespace chrono
  122.   {
  123.   _GLIBCXX_BEGIN_NAMESPACE_VERSION
  124.  
  125.     // Primary template for duration_cast impl.
  126.     template<typename _ToDur, typename _CF, typename _CR,
  127.              bool _NumIsOne = false, bool _DenIsOne = false>
  128.       struct __duration_cast_impl
  129.       {
  130.         template<typename _Rep, typename _Period>
  131.           static constexpr _ToDur
  132.           __cast(const duration<_Rep, _Period>& __d)
  133.           {
  134.             typedef typename _ToDur::rep                        __to_rep;
  135.             return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
  136.               * static_cast<_CR>(_CF::num)
  137.               / static_cast<_CR>(_CF::den)));
  138.           }
  139.       };
  140.  
  141.     template<typename _ToDur, typename _CF, typename _CR>
  142.       struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
  143.       {
  144.         template<typename _Rep, typename _Period>
  145.           static constexpr _ToDur
  146.           __cast(const duration<_Rep, _Period>& __d)
  147.           {
  148.             typedef typename _ToDur::rep                        __to_rep;
  149.             return _ToDur(static_cast<__to_rep>(__d.count()));
  150.           }
  151.       };
  152.  
  153.     template<typename _ToDur, typename _CF, typename _CR>
  154.       struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
  155.       {
  156.         template<typename _Rep, typename _Period>
  157.           static constexpr _ToDur
  158.           __cast(const duration<_Rep, _Period>& __d)
  159.           {
  160.             typedef typename _ToDur::rep                        __to_rep;
  161.             return _ToDur(static_cast<__to_rep>(
  162.               static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
  163.           }
  164.       };
  165.  
  166.     template<typename _ToDur, typename _CF, typename _CR>
  167.       struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
  168.       {
  169.         template<typename _Rep, typename _Period>
  170.           static constexpr _ToDur
  171.           __cast(const duration<_Rep, _Period>& __d)
  172.           {
  173.             typedef typename _ToDur::rep                        __to_rep;
  174.             return _ToDur(static_cast<__to_rep>(
  175.               static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
  176.           }
  177.       };
  178.  
  179.     template<typename _Tp>
  180.       struct __is_duration
  181.       : std::false_type
  182.       { };
  183.  
  184.     template<typename _Rep, typename _Period>
  185.       struct __is_duration<duration<_Rep, _Period>>
  186.       : std::true_type
  187.       { };
  188.  
  189.     /// duration_cast
  190.     template<typename _ToDur, typename _Rep, typename _Period>
  191.       constexpr typename enable_if<__is_duration<_ToDur>::value,
  192.                                    _ToDur>::type
  193.       duration_cast(const duration<_Rep, _Period>& __d)
  194.       {
  195.         typedef typename _ToDur::period                         __to_period;
  196.         typedef typename _ToDur::rep                            __to_rep;
  197.         typedef ratio_divide<_Period, __to_period>              __cf;
  198.         typedef typename common_type<__to_rep, _Rep, intmax_t>::type
  199.                                                                 __cr;
  200.         typedef  __duration_cast_impl<_ToDur, __cf, __cr,
  201.                                       __cf::num == 1, __cf::den == 1> __dc;
  202.         return __dc::__cast(__d);
  203.       }
  204.  
  205.     /// treat_as_floating_point
  206.     template<typename _Rep>
  207.       struct treat_as_floating_point
  208.       : is_floating_point<_Rep>
  209.       { };
  210.  
  211.     /// duration_values
  212.     template<typename _Rep>
  213.       struct duration_values
  214.       {
  215.         static constexpr _Rep
  216.         zero()
  217.         { return _Rep(0); }
  218.  
  219.         static constexpr _Rep
  220.         max()
  221.         { return numeric_limits<_Rep>::max(); }
  222.  
  223.         static constexpr _Rep
  224.         min()
  225.         { return numeric_limits<_Rep>::lowest(); }
  226.       };
  227.  
  228.     template<typename _Tp>
  229.       struct __is_ratio
  230.       : std::false_type
  231.       { };
  232.  
  233.     template<intmax_t _Num, intmax_t _Den>
  234.       struct __is_ratio<ratio<_Num, _Den>>
  235.       : std::true_type
  236.       { };
  237.  
  238.     /// duration
  239.     template<typename _Rep, typename _Period>
  240.       struct duration
  241.       {
  242.         typedef _Rep                                            rep;
  243.         typedef _Period                                         period;
  244.  
  245.         static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
  246.         static_assert(__is_ratio<_Period>::value,
  247.                       "period must be a specialization of ratio");
  248.         static_assert(_Period::num > 0, "period must be positive");
  249.  
  250.         // 20.11.5.1 construction / copy / destroy
  251.         constexpr duration() = default;
  252.  
  253.         // NB: Make constexpr implicit. This cannot be explicitly
  254.         // constexpr, as any UDT that is not a literal type with a
  255.         // constexpr copy constructor will be ill-formed.
  256.         duration(const duration&) = default;
  257.  
  258.         template<typename _Rep2, typename = typename
  259.                enable_if<is_convertible<_Rep2, rep>::value
  260.                          && (treat_as_floating_point<rep>::value
  261.                              || !treat_as_floating_point<_Rep2>::value)>::type>
  262.           constexpr explicit duration(const _Rep2& __rep)
  263.           : __r(static_cast<rep>(__rep)) { }
  264.  
  265.         template<typename _Rep2, typename _Period2, typename = typename
  266.                enable_if<treat_as_floating_point<rep>::value
  267.                          || (ratio_divide<_Period2, period>::den == 1
  268.                              && !treat_as_floating_point<_Rep2>::value)>::type>
  269.           constexpr duration(const duration<_Rep2, _Period2>& __d)
  270.           : __r(duration_cast<duration>(__d).count()) { }
  271.  
  272.         ~duration() = default;
  273.         duration& operator=(const duration&) = default;
  274.  
  275.         // 20.11.5.2 observer
  276.         constexpr rep
  277.         count() const
  278.         { return __r; }
  279.  
  280.         // 20.11.5.3 arithmetic
  281.         constexpr duration
  282.         operator+() const
  283.         { return *this; }
  284.  
  285.         constexpr duration
  286.         operator-() const
  287.         { return duration(-__r); }
  288.  
  289.         duration&
  290.         operator++()
  291.         {
  292.           ++__r;
  293.           return *this;
  294.         }
  295.  
  296.         duration
  297.         operator++(int)
  298.         { return duration(__r++); }
  299.  
  300.         duration&
  301.         operator--()
  302.         {
  303.           --__r;
  304.           return *this;
  305.         }
  306.  
  307.         duration
  308.         operator--(int)
  309.         { return duration(__r--); }
  310.  
  311.         duration&
  312.         operator+=(const duration& __d)
  313.         {
  314.           __r += __d.count();
  315.           return *this;
  316.         }
  317.  
  318.         duration&
  319.         operator-=(const duration& __d)
  320.         {
  321.           __r -= __d.count();
  322.           return *this;
  323.         }
  324.  
  325.         duration&
  326.         operator*=(const rep& __rhs)
  327.         {
  328.           __r *= __rhs;
  329.           return *this;
  330.         }
  331.  
  332.         duration&
  333.         operator/=(const rep& __rhs)
  334.         {
  335.           __r /= __rhs;
  336.           return *this;
  337.         }
  338.  
  339.         // DR 934.
  340.         template<typename _Rep2 = rep>
  341.           typename enable_if<!treat_as_floating_point<_Rep2>::value,
  342.                              duration&>::type
  343.           operator%=(const rep& __rhs)
  344.           {
  345.             __r %= __rhs;
  346.             return *this;
  347.           }
  348.  
  349.         template<typename _Rep2 = rep>
  350.           typename enable_if<!treat_as_floating_point<_Rep2>::value,
  351.                              duration&>::type
  352.           operator%=(const duration& __d)
  353.           {
  354.             __r %= __d.count();
  355.             return *this;
  356.           }
  357.  
  358.         // 20.11.5.4 special values
  359.         static constexpr duration
  360.         zero()
  361.         { return duration(duration_values<rep>::zero()); }
  362.  
  363.         static constexpr duration
  364.         min()
  365.         { return duration(duration_values<rep>::min()); }
  366.  
  367.         static constexpr duration
  368.         max()
  369.         { return duration(duration_values<rep>::max()); }
  370.  
  371.       private:
  372.         rep __r;
  373.       };
  374.  
  375.     template<typename _Rep1, typename _Period1,
  376.              typename _Rep2, typename _Period2>
  377.       constexpr typename common_type<duration<_Rep1, _Period1>,
  378.                                      duration<_Rep2, _Period2>>::type
  379.       operator+(const duration<_Rep1, _Period1>& __lhs,
  380.                 const duration<_Rep2, _Period2>& __rhs)
  381.       {
  382.         typedef duration<_Rep1, _Period1>                       __dur1;
  383.         typedef duration<_Rep2, _Period2>                       __dur2;
  384.         typedef typename common_type<__dur1,__dur2>::type       __cd;
  385.         return __cd(__cd(__lhs).count() + __cd(__rhs).count());
  386.       }
  387.  
  388.     template<typename _Rep1, typename _Period1,
  389.              typename _Rep2, typename _Period2>
  390.       constexpr typename common_type<duration<_Rep1, _Period1>,
  391.                                      duration<_Rep2, _Period2>>::type
  392.       operator-(const duration<_Rep1, _Period1>& __lhs,
  393.                 const duration<_Rep2, _Period2>& __rhs)
  394.       {
  395.         typedef duration<_Rep1, _Period1>                       __dur1;
  396.         typedef duration<_Rep2, _Period2>                       __dur2;
  397.         typedef typename common_type<__dur1,__dur2>::type       __cd;
  398.         return __cd(__cd(__lhs).count() - __cd(__rhs).count());
  399.       }
  400.  
  401.     template<typename _Rep1, typename _Rep2, bool =
  402.              is_convertible<_Rep2,
  403.                             typename common_type<_Rep1, _Rep2>::type>::value>
  404.       struct __common_rep_type { };
  405.  
  406.     template<typename _Rep1, typename _Rep2>
  407.       struct __common_rep_type<_Rep1, _Rep2, true>
  408.       { typedef typename common_type<_Rep1, _Rep2>::type type; };
  409.  
  410.     template<typename _Rep1, typename _Period, typename _Rep2>
  411.       constexpr
  412.       duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
  413.       operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
  414.       {
  415.         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
  416.           __cd;
  417.         return __cd(__cd(__d).count() * __s);
  418.       }
  419.  
  420.     template<typename _Rep1, typename _Rep2, typename _Period>
  421.       constexpr
  422.       duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
  423.       operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
  424.       { return __d * __s; }
  425.  
  426.     template<typename _Rep1, typename _Period, typename _Rep2>
  427.       constexpr duration<typename __common_rep_type<_Rep1, typename
  428.         enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
  429.       operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
  430.       {
  431.         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
  432.           __cd;
  433.         return __cd(__cd(__d).count() / __s);
  434.       }
  435.  
  436.     template<typename _Rep1, typename _Period1,
  437.              typename _Rep2, typename _Period2>
  438.       constexpr typename common_type<_Rep1, _Rep2>::type
  439.       operator/(const duration<_Rep1, _Period1>& __lhs,
  440.                 const duration<_Rep2, _Period2>& __rhs)
  441.       {
  442.         typedef duration<_Rep1, _Period1>                       __dur1;
  443.         typedef duration<_Rep2, _Period2>                       __dur2;
  444.         typedef typename common_type<__dur1,__dur2>::type       __cd;
  445.         return __cd(__lhs).count() / __cd(__rhs).count();
  446.       }
  447.  
  448.     // DR 934.
  449.     template<typename _Rep1, typename _Period, typename _Rep2>
  450.       constexpr duration<typename __common_rep_type<_Rep1, typename
  451.         enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
  452.       operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
  453.       {
  454.         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
  455.           __cd;
  456.         return __cd(__cd(__d).count() % __s);
  457.       }
  458.  
  459.     template<typename _Rep1, typename _Period1,
  460.              typename _Rep2, typename _Period2>
  461.       constexpr typename common_type<duration<_Rep1, _Period1>,
  462.                                      duration<_Rep2, _Period2>>::type
  463.       operator%(const duration<_Rep1, _Period1>& __lhs,
  464.                 const duration<_Rep2, _Period2>& __rhs)
  465.       {
  466.         typedef duration<_Rep1, _Period1>                       __dur1;
  467.         typedef duration<_Rep2, _Period2>                       __dur2;
  468.         typedef typename common_type<__dur1,__dur2>::type       __cd;
  469.         return __cd(__cd(__lhs).count() % __cd(__rhs).count());
  470.       }
  471.  
  472.     // comparisons
  473.     template<typename _Rep1, typename _Period1,
  474.              typename _Rep2, typename _Period2>
  475.       constexpr bool
  476.       operator==(const duration<_Rep1, _Period1>& __lhs,
  477.                  const duration<_Rep2, _Period2>& __rhs)
  478.       {
  479.         typedef duration<_Rep1, _Period1>                       __dur1;
  480.         typedef duration<_Rep2, _Period2>                       __dur2;
  481.         typedef typename common_type<__dur1,__dur2>::type       __ct;
  482.         return __ct(__lhs).count() == __ct(__rhs).count();
  483.       }
  484.  
  485.     template<typename _Rep1, typename _Period1,
  486.              typename _Rep2, typename _Period2>
  487.       constexpr bool
  488.       operator<(const duration<_Rep1, _Period1>& __lhs,
  489.                 const duration<_Rep2, _Period2>& __rhs)
  490.       {
  491.         typedef duration<_Rep1, _Period1>                       __dur1;
  492.         typedef duration<_Rep2, _Period2>                       __dur2;
  493.         typedef typename common_type<__dur1,__dur2>::type       __ct;
  494.         return __ct(__lhs).count() < __ct(__rhs).count();
  495.       }
  496.  
  497.     template<typename _Rep1, typename _Period1,
  498.              typename _Rep2, typename _Period2>
  499.       constexpr bool
  500.       operator!=(const duration<_Rep1, _Period1>& __lhs,
  501.                  const duration<_Rep2, _Period2>& __rhs)
  502.       { return !(__lhs == __rhs); }
  503.  
  504.     template<typename _Rep1, typename _Period1,
  505.              typename _Rep2, typename _Period2>
  506.       constexpr bool
  507.       operator<=(const duration<_Rep1, _Period1>& __lhs,
  508.                  const duration<_Rep2, _Period2>& __rhs)
  509.       { return !(__rhs < __lhs); }
  510.  
  511.     template<typename _Rep1, typename _Period1,
  512.              typename _Rep2, typename _Period2>
  513.       constexpr bool
  514.       operator>(const duration<_Rep1, _Period1>& __lhs,
  515.                 const duration<_Rep2, _Period2>& __rhs)
  516.       { return __rhs < __lhs; }
  517.  
  518.     template<typename _Rep1, typename _Period1,
  519.              typename _Rep2, typename _Period2>
  520.       constexpr bool
  521.       operator>=(const duration<_Rep1, _Period1>& __lhs,
  522.                  const duration<_Rep2, _Period2>& __rhs)
  523.       { return !(__lhs < __rhs); }
  524.  
  525.     /// nanoseconds
  526.     typedef duration<int64_t, nano>     nanoseconds;
  527.  
  528.     /// microseconds
  529.     typedef duration<int64_t, micro>    microseconds;
  530.  
  531.     /// milliseconds
  532.     typedef duration<int64_t, milli>    milliseconds;
  533.  
  534.     /// seconds
  535.     typedef duration<int64_t>           seconds;
  536.  
  537.     /// minutes
  538.     typedef duration<int, ratio< 60>>   minutes;
  539.  
  540.     /// hours
  541.     typedef duration<int, ratio<3600>>  hours;
  542.  
  543.     /// time_point
  544.     template<typename _Clock, typename _Dur>
  545.       struct time_point
  546.       {
  547.         typedef _Clock                                          clock;
  548.         typedef _Dur                                            duration;
  549.         typedef typename duration::rep                          rep;
  550.         typedef typename duration::period                       period;
  551.  
  552.         constexpr time_point() : __d(duration::zero())
  553.         { }
  554.  
  555.         constexpr explicit time_point(const duration& __dur)
  556.         : __d(__dur)
  557.         { }
  558.  
  559.         // conversions
  560.         template<typename _Dur2>
  561.           constexpr time_point(const time_point<clock, _Dur2>& __t)
  562.           : __d(__t.time_since_epoch())
  563.           { }
  564.  
  565.         // observer
  566.         constexpr duration
  567.         time_since_epoch() const
  568.         { return __d; }
  569.  
  570.         // arithmetic
  571.         time_point&
  572.         operator+=(const duration& __dur)
  573.         {
  574.           __d += __dur;
  575.           return *this;
  576.         }
  577.  
  578.         time_point&
  579.         operator-=(const duration& __dur)
  580.         {
  581.           __d -= __dur;
  582.           return *this;
  583.         }
  584.  
  585.         // special values
  586.         static constexpr time_point
  587.         min()
  588.         { return time_point(duration::min()); }
  589.  
  590.         static constexpr time_point
  591.         max()
  592.         { return time_point(duration::max()); }
  593.  
  594.       private:
  595.         duration __d;
  596.       };
  597.  
  598.     /// time_point_cast
  599.     template<typename _ToDur, typename _Clock, typename _Dur>
  600.       constexpr typename enable_if<__is_duration<_ToDur>::value,
  601.                                    time_point<_Clock, _ToDur>>::type
  602.       time_point_cast(const time_point<_Clock, _Dur>& __t)
  603.       {
  604.         typedef time_point<_Clock, _ToDur>                      __time_point;
  605.         return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
  606.       }
  607.  
  608.     template<typename _Clock, typename _Dur1,
  609.              typename _Rep2, typename _Period2>
  610.       constexpr time_point<_Clock,
  611.         typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
  612.       operator+(const time_point<_Clock, _Dur1>& __lhs,
  613.                 const duration<_Rep2, _Period2>& __rhs)
  614.       {
  615.         typedef duration<_Rep2, _Period2>                       __dur2;
  616.         typedef typename common_type<_Dur1,__dur2>::type        __ct;
  617.         typedef time_point<_Clock, __ct>                        __time_point;
  618.         return __time_point(__lhs.time_since_epoch() + __rhs);
  619.       }
  620.  
  621.     template<typename _Rep1, typename _Period1,
  622.              typename _Clock, typename _Dur2>
  623.       constexpr time_point<_Clock,
  624.         typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
  625.       operator+(const duration<_Rep1, _Period1>& __lhs,
  626.                 const time_point<_Clock, _Dur2>& __rhs)
  627.       {
  628.         typedef duration<_Rep1, _Period1>                       __dur1;
  629.         typedef typename common_type<__dur1,_Dur2>::type        __ct;
  630.         typedef time_point<_Clock, __ct>                        __time_point;
  631.         return __time_point(__rhs.time_since_epoch() + __lhs);
  632.       }
  633.  
  634.     template<typename _Clock, typename _Dur1,
  635.              typename _Rep2, typename _Period2>
  636.       constexpr time_point<_Clock,
  637.         typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
  638.       operator-(const time_point<_Clock, _Dur1>& __lhs,
  639.                 const duration<_Rep2, _Period2>& __rhs)
  640.       {
  641.         typedef duration<_Rep2, _Period2>                       __dur2;
  642.         typedef typename common_type<_Dur1,__dur2>::type        __ct;
  643.         typedef time_point<_Clock, __ct>                        __time_point;
  644.         return __time_point(__lhs.time_since_epoch() -__rhs);
  645.       }
  646.  
  647.     template<typename _Clock, typename _Dur1, typename _Dur2>
  648.       constexpr typename common_type<_Dur1, _Dur2>::type
  649.       operator-(const time_point<_Clock, _Dur1>& __lhs,
  650.                 const time_point<_Clock, _Dur2>& __rhs)
  651.       { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
  652.  
  653.     template<typename _Clock, typename _Dur1, typename _Dur2>
  654.       constexpr bool
  655.       operator==(const time_point<_Clock, _Dur1>& __lhs,
  656.                  const time_point<_Clock, _Dur2>& __rhs)
  657.       { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
  658.  
  659.     template<typename _Clock, typename _Dur1, typename _Dur2>
  660.       constexpr bool
  661.       operator!=(const time_point<_Clock, _Dur1>& __lhs,
  662.                  const time_point<_Clock, _Dur2>& __rhs)
  663.       { return !(__lhs == __rhs); }
  664.  
  665.     template<typename _Clock, typename _Dur1, typename _Dur2>
  666.       constexpr bool
  667.       operator<(const time_point<_Clock, _Dur1>& __lhs,
  668.                 const time_point<_Clock, _Dur2>& __rhs)
  669.       { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
  670.  
  671.     template<typename _Clock, typename _Dur1, typename _Dur2>
  672.       constexpr bool
  673.       operator<=(const time_point<_Clock, _Dur1>& __lhs,
  674.                  const time_point<_Clock, _Dur2>& __rhs)
  675.       { return !(__rhs < __lhs); }
  676.  
  677.     template<typename _Clock, typename _Dur1, typename _Dur2>
  678.       constexpr bool
  679.       operator>(const time_point<_Clock, _Dur1>& __lhs,
  680.                 const time_point<_Clock, _Dur2>& __rhs)
  681.       { return __rhs < __lhs; }
  682.  
  683.     template<typename _Clock, typename _Dur1, typename _Dur2>
  684.       constexpr bool
  685.       operator>=(const time_point<_Clock, _Dur1>& __lhs,
  686.                  const time_point<_Clock, _Dur2>& __rhs)
  687.       { return !(__lhs < __rhs); }
  688.  
  689.  
  690.     // Clocks.
  691.  
  692.     // Why nanosecond resolution as the default?  
  693.     // Why have std::system_clock always count in the higest
  694.     // resolution (ie nanoseconds), even if on some OSes the low 3
  695.     // or 9 decimal digits will be always zero? This allows later
  696.     // implementations to change the system_clock::now()
  697.     // implementation any time to provide better resolution without
  698.     // changing function signature or units.
  699.  
  700.     // To support the (forward) evolution of the library's defined
  701.     // clocks, wrap inside inline namespace so that the current
  702.     // defintions of system_clock, steady_clock, and
  703.     // high_resolution_clock types are uniquely mangled. This way, new
  704.     // code can use the latests clocks, while the library can contain
  705.     // compatibility definitions for previous versions.  At some
  706.     // point, when these clocks settle down, the inlined namespaces
  707.     // can be removed.  XXX GLIBCXX_ABI Deprecated
  708.     inline namespace _V2 {
  709.  
  710.     /**
  711.      *  @brief System clock.
  712.      *
  713.      *  Time returned represents wall time from the system-wide clock.
  714.     */
  715.      struct system_clock
  716.     {
  717.       typedef chrono::nanoseconds                               duration;
  718.       typedef duration::rep                                     rep;
  719.       typedef duration::period                                  period;
  720.       typedef chrono::time_point<system_clock, duration>        time_point;
  721.  
  722.       static_assert(system_clock::duration::min()
  723.                     < system_clock::duration::zero(),
  724.                     "a clock's minimum duration cannot be less than its epoch");
  725.  
  726.       static constexpr bool is_steady = false;
  727.  
  728.       static time_point
  729.       now() noexcept;
  730.  
  731.       // Map to C API
  732.       static std::time_t
  733.       to_time_t(const time_point& __t) noexcept
  734.       {
  735.         return std::time_t(duration_cast<chrono::seconds>
  736.                            (__t.time_since_epoch()).count());
  737.       }
  738.  
  739.       static time_point
  740.       from_time_t(std::time_t __t) noexcept
  741.       {
  742.         typedef chrono::time_point<system_clock, seconds>       __from;
  743.         return time_point_cast<system_clock::duration>
  744.                (__from(chrono::seconds(__t)));
  745.       }
  746.     };
  747.  
  748.  
  749.     /**
  750.      *  @brief Monotonic clock
  751.      *
  752.      *  Time returned has the property of only increasing at a uniform rate.
  753.     */
  754.     struct steady_clock
  755.     {
  756.       typedef chrono::nanoseconds                               duration;
  757.       typedef duration::rep                                     rep;
  758.       typedef duration::period                                  period;
  759.       typedef chrono::time_point<steady_clock, duration>        time_point;
  760.  
  761.       static constexpr bool is_steady = true;
  762.  
  763.       static time_point
  764.       now() noexcept;
  765.     };
  766.  
  767.  
  768.     /**
  769.      *  @brief Highest-resolution clock
  770.      *
  771.      *  This is the clock "with the shortest tick period." Alias to
  772.      *  std::system_clock until higher-than-nanosecond definitions
  773.      *  become feasible.
  774.     */
  775.     using high_resolution_clock = system_clock;
  776.  
  777.   } // end inline namespace _V2
  778.  
  779.   _GLIBCXX_END_NAMESPACE_VERSION
  780.   } // namespace chrono
  781.  
  782.   // @} group chrono
  783. } // namespace
  784.  
  785. #endif //_GLIBCXX_USE_C99_STDINT_TR1
  786.  
  787. #endif // C++11
  788.  
  789. #endif //_GLIBCXX_CHRONO
  790.