API tools faq
paste
Advertisement
Garey

chrono library

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