LCOV - code coverage report
Current view: top level - usr/include/c++/7 - chrono (source / functions) Hit Total Coverage
Test: coverage.info Lines: 30 30 100.0 %
Date: 2020-10-15 20:26:03 Functions: 22 22 100.0 %

          Line data    Source code
       1             : // <chrono> -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2008-2017 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           5 :           __cast(const duration<_Rep, _Period>& __d)
     160             :           {
     161             :             typedef typename _ToDur::rep                        __to_rep;
     162             :             return _ToDur(static_cast<__to_rep>(
     163           5 :               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          10 :           __cast(const duration<_Rep, _Period>& __d)
     173             :           {
     174             :             typedef typename _ToDur::rep                        __to_rep;
     175             :             return _ToDur(static_cast<__to_rep>(
     176          10 :               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          15 :       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          15 :         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             : #if __cplusplus > 201402L
     213             :     template <typename _Rep>
     214             :       inline constexpr bool treat_as_floating_point_v =
     215             :         treat_as_floating_point<_Rep>::value;
     216             : #endif // C++17
     217             : 
     218             : #if __cplusplus >= 201703L
     219             : # define __cpp_lib_chrono 201611
     220             : 
     221             :     template<typename _ToDur, typename _Rep, typename _Period>
     222             :       constexpr enable_if_t<__is_duration<_ToDur>::value, _ToDur>
     223             :       floor(const duration<_Rep, _Period>& __d)
     224             :       {
     225             :         auto __to = chrono::duration_cast<_ToDur>(__d);
     226             :         if (__to > __d)
     227             :           return __to - _ToDur{1};
     228             :         return __to;
     229             :       }
     230             : 
     231             :     template<typename _ToDur, typename _Rep, typename _Period>
     232             :       constexpr enable_if_t<__is_duration<_ToDur>::value, _ToDur>
     233             :       ceil(const duration<_Rep, _Period>& __d)
     234             :       {
     235             :         auto __to = chrono::duration_cast<_ToDur>(__d);
     236             :         if (__to < __d)
     237             :           return __to + _ToDur{1};
     238             :         return __to;
     239             :       }
     240             : 
     241             :     template <typename _ToDur, typename _Rep, typename _Period>
     242             :       constexpr enable_if_t<
     243             :         __and_<__is_duration<_ToDur>,
     244             :                __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
     245             :         _ToDur>
     246             :       round(const duration<_Rep, _Period>& __d)
     247             :       {
     248             :         _ToDur __t0 = chrono::floor<_ToDur>(__d);
     249             :         _ToDur __t1 = __t0 + _ToDur{1};
     250             :         auto __diff0 = __d - __t0;
     251             :         auto __diff1 = __t1 - __d;
     252             :         if (__diff0 == __diff1)
     253             :         {
     254             :             if (__t0.count() & 1)
     255             :                 return __t1;
     256             :             return __t0;
     257             :         }
     258             :         else if (__diff0 < __diff1)
     259             :             return __t0;
     260             :         return __t1;
     261             :       }
     262             : 
     263             :     template<typename _Rep, typename _Period>
     264             :       constexpr
     265             :       enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
     266             :       abs(duration<_Rep, _Period> __d)
     267             :       {
     268             :         if (__d >= __d.zero())
     269             :           return __d;
     270             :         return -__d;
     271             :       }
     272             : #endif // C++17
     273             : 
     274             :     /// duration_values
     275             :     template<typename _Rep>
     276             :       struct duration_values
     277             :       {
     278             :         static constexpr _Rep
     279           5 :         zero()
     280           5 :         { return _Rep(0); }
     281             : 
     282             :         static constexpr _Rep
     283             :         max()
     284             :         { return numeric_limits<_Rep>::max(); }
     285             : 
     286             :         static constexpr _Rep
     287             :         min()
     288             :         { return numeric_limits<_Rep>::lowest(); }
     289             :       };
     290             : 
     291             :     template<typename _Tp>
     292             :       struct __is_ratio
     293             :       : std::false_type
     294             :       { };
     295             : 
     296             :     template<intmax_t _Num, intmax_t _Den>
     297             :       struct __is_ratio<ratio<_Num, _Den>>
     298             :       : std::true_type
     299             :       { };
     300             : 
     301             :     /// duration
     302             :     template<typename _Rep, typename _Period>
     303             :       struct duration
     304             :       {
     305             :         typedef _Rep                                            rep;
     306             :         typedef _Period                                         period;
     307             : 
     308             :         static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
     309             :         static_assert(__is_ratio<_Period>::value,
     310             :                       "period must be a specialization of ratio");
     311             :         static_assert(_Period::num > 0, "period must be positive");
     312             : 
     313             :         // 20.11.5.1 construction / copy / destroy
     314             :         constexpr duration() = default;
     315             : 
     316             :         // NB: Make constexpr implicit. This cannot be explicitly
     317             :         // constexpr, as any UDT that is not a literal type with a
     318             :         // constexpr copy constructor will be ill-formed.
     319             :         duration(const duration&) = default;
     320             : 
     321             :         // _GLIBCXX_RESOLVE_LIB_DEFECTS
     322             :         // 3050. Conversion specification problem in chrono::duration
     323             :         template<typename _Rep2, typename = typename
     324             :                enable_if<is_convertible<const _Rep2&, rep>::value
     325             :                          && (treat_as_floating_point<rep>::value
     326             :                              || !treat_as_floating_point<_Rep2>::value)>::type>
     327          30 :           constexpr explicit duration(const _Rep2& __rep)
     328          30 :           : __r(static_cast<rep>(__rep)) { }
     329             : 
     330             :         template<typename _Rep2, typename _Period2, typename = typename
     331             :                enable_if<treat_as_floating_point<rep>::value
     332             :                          || (ratio_divide<_Period2, period>::den == 1
     333             :                              && !treat_as_floating_point<_Rep2>::value)>::type>
     334           5 :           constexpr duration(const duration<_Rep2, _Period2>& __d)
     335           5 :           : __r(duration_cast<duration>(__d).count()) { }
     336             : 
     337             :         ~duration() = default;
     338             :         duration& operator=(const duration&) = default;
     339             : 
     340             :         // 20.11.5.2 observer
     341             :         constexpr rep
     342          60 :         count() const
     343          60 :         { return __r; }
     344             : 
     345             :         // 20.11.5.3 arithmetic
     346             :         constexpr duration
     347             :         operator+() const
     348             :         { return *this; }
     349             : 
     350             :         constexpr duration
     351             :         operator-() const
     352             :         { return duration(-__r); }
     353             : 
     354             :         _GLIBCXX17_CONSTEXPR duration&
     355             :         operator++()
     356             :         {
     357             :           ++__r;
     358             :           return *this;
     359             :         }
     360             : 
     361             :         _GLIBCXX17_CONSTEXPR duration
     362             :         operator++(int)
     363             :         { return duration(__r++); }
     364             : 
     365             :         _GLIBCXX17_CONSTEXPR duration&
     366             :         operator--()
     367             :         {
     368             :           --__r;
     369             :           return *this;
     370             :         }
     371             : 
     372             :         _GLIBCXX17_CONSTEXPR duration
     373             :         operator--(int)
     374             :         { return duration(__r--); }
     375             : 
     376             :         _GLIBCXX17_CONSTEXPR duration&
     377             :         operator+=(const duration& __d)
     378             :         {
     379             :           __r += __d.count();
     380             :           return *this;
     381             :         }
     382             : 
     383             :         _GLIBCXX17_CONSTEXPR duration&
     384             :         operator-=(const duration& __d)
     385             :         {
     386             :           __r -= __d.count();
     387             :           return *this;
     388             :         }
     389             : 
     390             :         _GLIBCXX17_CONSTEXPR duration&
     391             :         operator*=(const rep& __rhs)
     392             :         {
     393             :           __r *= __rhs;
     394             :           return *this;
     395             :         }
     396             : 
     397             :         _GLIBCXX17_CONSTEXPR duration&
     398             :         operator/=(const rep& __rhs)
     399             :         {
     400             :           __r /= __rhs;
     401             :           return *this;
     402             :         }
     403             : 
     404             :         // DR 934.
     405             :         template<typename _Rep2 = rep>
     406             :           _GLIBCXX17_CONSTEXPR
     407             :           typename enable_if<!treat_as_floating_point<_Rep2>::value,
     408             :                              duration&>::type
     409             :           operator%=(const rep& __rhs)
     410             :           {
     411             :             __r %= __rhs;
     412             :             return *this;
     413             :           }
     414             : 
     415             :         template<typename _Rep2 = rep>
     416             :           _GLIBCXX17_CONSTEXPR
     417             :           typename enable_if<!treat_as_floating_point<_Rep2>::value,
     418             :                              duration&>::type
     419             :           operator%=(const duration& __d)
     420             :           {
     421             :             __r %= __d.count();
     422             :             return *this;
     423             :           }
     424             : 
     425             :         // 20.11.5.4 special values
     426             :         static constexpr duration
     427           5 :         zero()
     428           5 :         { return duration(duration_values<rep>::zero()); }
     429             : 
     430             :         static constexpr duration
     431             :         min()
     432             :         { return duration(duration_values<rep>::min()); }
     433             : 
     434             :         static constexpr duration
     435             :         max()
     436             :         { return duration(duration_values<rep>::max()); }
     437             : 
     438             :       private:
     439             :         rep __r;
     440             :       };
     441             : 
     442             :     template<typename _Rep1, typename _Period1,
     443             :              typename _Rep2, typename _Period2>
     444             :       constexpr typename common_type<duration<_Rep1, _Period1>,
     445             :                                      duration<_Rep2, _Period2>>::type
     446             :       operator+(const duration<_Rep1, _Period1>& __lhs,
     447             :                 const duration<_Rep2, _Period2>& __rhs)
     448             :       {
     449             :         typedef duration<_Rep1, _Period1>                 __dur1;
     450             :         typedef duration<_Rep2, _Period2>                 __dur2;
     451             :         typedef typename common_type<__dur1,__dur2>::type __cd;
     452             :         return __cd(__cd(__lhs).count() + __cd(__rhs).count());
     453             :       }
     454             : 
     455             :     template<typename _Rep1, typename _Period1,
     456             :              typename _Rep2, typename _Period2>
     457             :       constexpr typename common_type<duration<_Rep1, _Period1>,
     458             :                                      duration<_Rep2, _Period2>>::type
     459           5 :       operator-(const duration<_Rep1, _Period1>& __lhs,
     460             :                 const duration<_Rep2, _Period2>& __rhs)
     461             :       {
     462             :         typedef duration<_Rep1, _Period1>                 __dur1;
     463             :         typedef duration<_Rep2, _Period2>                 __dur2;
     464             :         typedef typename common_type<__dur1,__dur2>::type __cd;
     465           5 :         return __cd(__cd(__lhs).count() - __cd(__rhs).count());
     466             :       }
     467             : 
     468             :     // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2
     469             :     // is implicitly convertible to it.
     470             :     // _GLIBCXX_RESOLVE_LIB_DEFECTS
     471             :     // 3050. Conversion specification problem in chrono::duration constructor
     472             :     template<typename _Rep1, typename _Rep2, bool =
     473             :              is_convertible<const _Rep2&,
     474             :                             typename common_type<_Rep1, _Rep2>::type>::value>
     475             :       struct __common_rep_type { };
     476             : 
     477             :     template<typename _Rep1, typename _Rep2>
     478             :       struct __common_rep_type<_Rep1, _Rep2, true>
     479             :       { typedef typename common_type<_Rep1, _Rep2>::type type; };
     480             : 
     481             :     template<typename _Rep1, typename _Period, typename _Rep2>
     482             :       constexpr
     483             :       duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
     484             :       operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
     485             :       {
     486             :         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
     487             :           __cd;
     488             :         return __cd(__cd(__d).count() * __s);
     489             :       }
     490             : 
     491             :     template<typename _Rep1, typename _Rep2, typename _Period>
     492             :       constexpr
     493             :       duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
     494             :       operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
     495             :       { return __d * __s; }
     496             : 
     497             :     template<typename _Rep1, typename _Period, typename _Rep2>
     498             :       constexpr duration<typename __common_rep_type<_Rep1, typename
     499             :         enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
     500             :       operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
     501             :       {
     502             :         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
     503             :           __cd;
     504             :         return __cd(__cd(__d).count() / __s);
     505             :       }
     506             : 
     507             :     template<typename _Rep1, typename _Period1,
     508             :              typename _Rep2, typename _Period2>
     509             :       constexpr typename common_type<_Rep1, _Rep2>::type
     510             :       operator/(const duration<_Rep1, _Period1>& __lhs,
     511             :                 const duration<_Rep2, _Period2>& __rhs)
     512             :       {
     513             :         typedef duration<_Rep1, _Period1>                 __dur1;
     514             :         typedef duration<_Rep2, _Period2>                 __dur2;
     515             :         typedef typename common_type<__dur1,__dur2>::type __cd;
     516             :         return __cd(__lhs).count() / __cd(__rhs).count();
     517             :       }
     518             : 
     519             :     // DR 934.
     520             :     template<typename _Rep1, typename _Period, typename _Rep2>
     521             :       constexpr duration<typename __common_rep_type<_Rep1, typename
     522             :         enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
     523             :       operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
     524             :       {
     525             :         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
     526             :           __cd;
     527             :         return __cd(__cd(__d).count() % __s);
     528             :       }
     529             : 
     530             :     template<typename _Rep1, typename _Period1,
     531             :              typename _Rep2, typename _Period2>
     532             :       constexpr typename common_type<duration<_Rep1, _Period1>,
     533             :                                      duration<_Rep2, _Period2>>::type
     534             :       operator%(const duration<_Rep1, _Period1>& __lhs,
     535             :                 const duration<_Rep2, _Period2>& __rhs)
     536             :       {
     537             :         typedef duration<_Rep1, _Period1>                 __dur1;
     538             :         typedef duration<_Rep2, _Period2>                 __dur2;
     539             :         typedef typename common_type<__dur1,__dur2>::type __cd;
     540             :         return __cd(__cd(__lhs).count() % __cd(__rhs).count());
     541             :       }
     542             : 
     543             :     // comparisons
     544             :     template<typename _Rep1, typename _Period1,
     545             :              typename _Rep2, typename _Period2>
     546             :       constexpr bool
     547           5 :       operator==(const duration<_Rep1, _Period1>& __lhs,
     548             :                  const duration<_Rep2, _Period2>& __rhs)
     549             :       {
     550             :         typedef duration<_Rep1, _Period1>                 __dur1;
     551             :         typedef duration<_Rep2, _Period2>                 __dur2;
     552             :         typedef typename common_type<__dur1,__dur2>::type __ct;
     553           5 :         return __ct(__lhs).count() == __ct(__rhs).count();
     554             :       }
     555             : 
     556             :     template<typename _Rep1, typename _Period1,
     557             :              typename _Rep2, typename _Period2>
     558             :       constexpr bool
     559           5 :       operator<(const duration<_Rep1, _Period1>& __lhs,
     560             :                 const duration<_Rep2, _Period2>& __rhs)
     561             :       {
     562             :         typedef duration<_Rep1, _Period1>                 __dur1;
     563             :         typedef duration<_Rep2, _Period2>                 __dur2;
     564             :         typedef typename common_type<__dur1,__dur2>::type __ct;
     565           5 :         return __ct(__lhs).count() < __ct(__rhs).count();
     566             :       }
     567             : 
     568             :     template<typename _Rep1, typename _Period1,
     569             :              typename _Rep2, typename _Period2>
     570             :       constexpr bool
     571           5 :       operator!=(const duration<_Rep1, _Period1>& __lhs,
     572             :                  const duration<_Rep2, _Period2>& __rhs)
     573           5 :       { return !(__lhs == __rhs); }
     574             : 
     575             :     template<typename _Rep1, typename _Period1,
     576             :              typename _Rep2, typename _Period2>
     577             :       constexpr bool
     578           5 :       operator<=(const duration<_Rep1, _Period1>& __lhs,
     579             :                  const duration<_Rep2, _Period2>& __rhs)
     580           5 :       { return !(__rhs < __lhs); }
     581             : 
     582             :     template<typename _Rep1, typename _Period1,
     583             :              typename _Rep2, typename _Period2>
     584             :       constexpr bool
     585             :       operator>(const duration<_Rep1, _Period1>& __lhs,
     586             :                 const duration<_Rep2, _Period2>& __rhs)
     587             :       { return __rhs < __lhs; }
     588             : 
     589             :     template<typename _Rep1, typename _Period1,
     590             :              typename _Rep2, typename _Period2>
     591             :       constexpr bool
     592             :       operator>=(const duration<_Rep1, _Period1>& __lhs,
     593             :                  const duration<_Rep2, _Period2>& __rhs)
     594             :       { return !(__lhs < __rhs); }
     595             : 
     596             :     /// nanoseconds
     597             :     typedef duration<int64_t, nano>           nanoseconds;
     598             : 
     599             :     /// microseconds
     600             :     typedef duration<int64_t, micro>          microseconds;
     601             : 
     602             :     /// milliseconds
     603             :     typedef duration<int64_t, milli>          milliseconds;
     604             : 
     605             :     /// seconds
     606             :     typedef duration<int64_t>                 seconds;
     607             : 
     608             :     /// minutes
     609             :     typedef duration<int64_t, ratio< 60>>   minutes;
     610             : 
     611             :     /// hours
     612             :     typedef duration<int64_t, ratio<3600>>  hours;
     613             : 
     614             :     /// time_point
     615             :     template<typename _Clock, typename _Dur>
     616             :       struct time_point
     617             :       {
     618             :         typedef _Clock                                          clock;
     619             :         typedef _Dur                                            duration;
     620             :         typedef typename duration::rep                          rep;
     621             :         typedef typename duration::period                       period;
     622             : 
     623             :         constexpr time_point() : __d(duration::zero())
     624             :         { }
     625             : 
     626             :         constexpr explicit time_point(const duration& __dur)
     627             :         : __d(__dur)
     628             :         { }
     629             : 
     630             :         // conversions
     631             :         template<typename _Dur2,
     632             :                  typename = _Require<is_convertible<_Dur2, _Dur>>>
     633             :           constexpr time_point(const time_point<clock, _Dur2>& __t)
     634             :           : __d(__t.time_since_epoch())
     635             :           { }
     636             : 
     637             :         // observer
     638             :         constexpr duration
     639             :         time_since_epoch() const
     640             :         { return __d; }
     641             : 
     642             :         // arithmetic
     643             :         _GLIBCXX17_CONSTEXPR time_point&
     644             :         operator+=(const duration& __dur)
     645             :         {
     646             :           __d += __dur;
     647             :           return *this;
     648             :         }
     649             : 
     650             :         _GLIBCXX17_CONSTEXPR time_point&
     651             :         operator-=(const duration& __dur)
     652             :         {
     653             :           __d -= __dur;
     654             :           return *this;
     655             :         }
     656             : 
     657             :         // special values
     658             :         static constexpr time_point
     659             :         min()
     660             :         { return time_point(duration::min()); }
     661             : 
     662             :         static constexpr time_point
     663             :         max()
     664             :         { return time_point(duration::max()); }
     665             : 
     666             :       private:
     667             :         duration __d;
     668             :       };
     669             : 
     670             :     /// time_point_cast
     671             :     template<typename _ToDur, typename _Clock, typename _Dur>
     672             :       constexpr typename enable_if<__is_duration<_ToDur>::value,
     673             :                                    time_point<_Clock, _ToDur>>::type
     674             :       time_point_cast(const time_point<_Clock, _Dur>& __t)
     675             :       {
     676             :         typedef time_point<_Clock, _ToDur>                        __time_point;
     677             :         return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
     678             :       }
     679             : 
     680             : #if __cplusplus > 201402L
     681             :     template<typename _ToDur, typename _Clock, typename _Dur>
     682             :       constexpr
     683             :       enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
     684             :       floor(const time_point<_Clock, _Dur>& __tp)
     685             :       {
     686             :         return time_point<_Clock, _ToDur>{
     687             :             chrono::floor<_ToDur>(__tp.time_since_epoch())};
     688             :       }
     689             : 
     690             :     template<typename _ToDur, typename _Clock, typename _Dur>
     691             :       constexpr
     692             :       enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
     693             :       ceil(const time_point<_Clock, _Dur>& __tp)
     694             :       {
     695             :         return time_point<_Clock, _ToDur>{
     696             :             chrono::ceil<_ToDur>(__tp.time_since_epoch())};
     697             :       }
     698             : 
     699             :     template<typename _ToDur, typename _Clock, typename _Dur>
     700             :       constexpr enable_if_t<
     701             :         __and_<__is_duration<_ToDur>,
     702             :                __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
     703             :         time_point<_Clock, _ToDur>>
     704             :       round(const time_point<_Clock, _Dur>& __tp)
     705             :       {
     706             :         return time_point<_Clock, _ToDur>{
     707             :             chrono::round<_ToDur>(__tp.time_since_epoch())};
     708             :       }
     709             : #endif // C++17
     710             : 
     711             :     template<typename _Clock, typename _Dur1,
     712             :              typename _Rep2, typename _Period2>
     713             :       constexpr time_point<_Clock,
     714             :         typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
     715             :       operator+(const time_point<_Clock, _Dur1>& __lhs,
     716             :                 const duration<_Rep2, _Period2>& __rhs)
     717             :       {
     718             :         typedef duration<_Rep2, _Period2>                 __dur2;
     719             :         typedef typename common_type<_Dur1,__dur2>::type  __ct;
     720             :         typedef time_point<_Clock, __ct>                  __time_point;
     721             :         return __time_point(__lhs.time_since_epoch() + __rhs);
     722             :       }
     723             : 
     724             :     template<typename _Rep1, typename _Period1,
     725             :              typename _Clock, typename _Dur2>
     726             :       constexpr time_point<_Clock,
     727             :         typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
     728             :       operator+(const duration<_Rep1, _Period1>& __lhs,
     729             :                 const time_point<_Clock, _Dur2>& __rhs)
     730             :       {
     731             :         typedef duration<_Rep1, _Period1>                 __dur1;
     732             :         typedef typename common_type<__dur1,_Dur2>::type  __ct;
     733             :         typedef time_point<_Clock, __ct>                  __time_point;
     734             :         return __time_point(__rhs.time_since_epoch() + __lhs);
     735             :       }
     736             : 
     737             :     template<typename _Clock, typename _Dur1,
     738             :              typename _Rep2, typename _Period2>
     739             :       constexpr time_point<_Clock,
     740             :         typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
     741             :       operator-(const time_point<_Clock, _Dur1>& __lhs,
     742             :                 const duration<_Rep2, _Period2>& __rhs)
     743             :       {
     744             :         typedef duration<_Rep2, _Period2>                 __dur2;
     745             :         typedef typename common_type<_Dur1,__dur2>::type  __ct;
     746             :         typedef time_point<_Clock, __ct>                  __time_point;
     747             :         return __time_point(__lhs.time_since_epoch() -__rhs);
     748             :       }
     749             : 
     750             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     751             :       constexpr typename common_type<_Dur1, _Dur2>::type
     752             :       operator-(const time_point<_Clock, _Dur1>& __lhs,
     753             :                 const time_point<_Clock, _Dur2>& __rhs)
     754             :       { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
     755             : 
     756             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     757             :       constexpr bool
     758             :       operator==(const time_point<_Clock, _Dur1>& __lhs,
     759             :                  const time_point<_Clock, _Dur2>& __rhs)
     760             :       { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
     761             : 
     762             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     763             :       constexpr bool
     764             :       operator!=(const time_point<_Clock, _Dur1>& __lhs,
     765             :                  const time_point<_Clock, _Dur2>& __rhs)
     766             :       { return !(__lhs == __rhs); }
     767             : 
     768             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     769             :       constexpr bool
     770             :       operator<(const time_point<_Clock, _Dur1>& __lhs,
     771             :                 const time_point<_Clock, _Dur2>& __rhs)
     772             :       { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
     773             : 
     774             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     775             :       constexpr bool
     776             :       operator<=(const time_point<_Clock, _Dur1>& __lhs,
     777             :                  const time_point<_Clock, _Dur2>& __rhs)
     778             :       { return !(__rhs < __lhs); }
     779             : 
     780             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     781             :       constexpr bool
     782             :       operator>(const time_point<_Clock, _Dur1>& __lhs,
     783             :                 const time_point<_Clock, _Dur2>& __rhs)
     784             :       { return __rhs < __lhs; }
     785             : 
     786             :     template<typename _Clock, typename _Dur1, typename _Dur2>
     787             :       constexpr bool
     788             :       operator>=(const time_point<_Clock, _Dur1>& __lhs,
     789             :                  const time_point<_Clock, _Dur2>& __rhs)
     790             :       { return !(__lhs < __rhs); }
     791             : 
     792             : 
     793             :     // Clocks.
     794             : 
     795             :     // Why nanosecond resolution as the default?
     796             :     // Why have std::system_clock always count in the highest
     797             :     // resolution (ie nanoseconds), even if on some OSes the low 3
     798             :     // or 9 decimal digits will be always zero? This allows later
     799             :     // implementations to change the system_clock::now()
     800             :     // implementation any time to provide better resolution without
     801             :     // changing function signature or units.
     802             : 
     803             :     // To support the (forward) evolution of the library's defined
     804             :     // clocks, wrap inside inline namespace so that the current
     805             :     // defintions of system_clock, steady_clock, and
     806             :     // high_resolution_clock types are uniquely mangled. This way, new
     807             :     // code can use the latests clocks, while the library can contain
     808             :     // compatibility definitions for previous versions.  At some
     809             :     // point, when these clocks settle down, the inlined namespaces
     810             :     // can be removed.  XXX GLIBCXX_ABI Deprecated
     811             :     inline namespace _V2 {
     812             : 
     813             :     /**
     814             :      *  @brief System clock.
     815             :      *
     816             :      *  Time returned represents wall time from the system-wide clock.
     817             :     */
     818             :     struct system_clock
     819             :     {
     820             :       typedef chrono::nanoseconds                               duration;
     821             :       typedef duration::rep                                     rep;
     822             :       typedef duration::period                                  period;
     823             :       typedef chrono::time_point<system_clock, duration>  time_point;
     824             : 
     825             :       static_assert(system_clock::duration::min()
     826             :                     < system_clock::duration::zero(),
     827             :                     "a clock's minimum duration cannot be less than its epoch");
     828             : 
     829             :       static constexpr bool is_steady = false;
     830             : 
     831             :       static time_point
     832             :       now() noexcept;
     833             : 
     834             :       // Map to C API
     835             :       static std::time_t
     836             :       to_time_t(const time_point& __t) noexcept
     837             :       {
     838             :         return std::time_t(duration_cast<chrono::seconds>
     839             :                            (__t.time_since_epoch()).count());
     840             :       }
     841             : 
     842             :       static time_point
     843             :       from_time_t(std::time_t __t) noexcept
     844             :       {
     845             :         typedef chrono::time_point<system_clock, seconds> __from;
     846             :         return time_point_cast<system_clock::duration>
     847             :                (__from(chrono::seconds(__t)));
     848             :       }
     849             :     };
     850             : 
     851             : 
     852             :     /**
     853             :      *  @brief Monotonic clock
     854             :      *
     855             :      *  Time returned has the property of only increasing at a uniform rate.
     856             :     */
     857             :     struct steady_clock
     858             :     {
     859             :       typedef chrono::nanoseconds                               duration;
     860             :       typedef duration::rep                                     rep;
     861             :       typedef duration::period                                  period;
     862             :       typedef chrono::time_point<steady_clock, duration>  time_point;
     863             : 
     864             :       static constexpr bool is_steady = true;
     865             : 
     866             :       static time_point
     867             :       now() noexcept;
     868             :     };
     869             : 
     870             : 
     871             :     /**
     872             :      *  @brief Highest-resolution clock
     873             :      *
     874             :      *  This is the clock "with the shortest tick period." Alias to
     875             :      *  std::system_clock until higher-than-nanosecond definitions
     876             :      *  become feasible.
     877             :     */
     878             :     using high_resolution_clock = system_clock;
     879             : 
     880             :     } // end inline namespace _V2
     881             : 
     882             :   _GLIBCXX_END_NAMESPACE_VERSION
     883             :   } // namespace chrono
     884             : 
     885             : #if __cplusplus > 201103L
     886             : 
     887             : #define __cpp_lib_chrono_udls 201304
     888             : 
     889             :   inline namespace literals
     890             :   {
     891             :   inline namespace chrono_literals
     892             :   {
     893             :   _GLIBCXX_BEGIN_NAMESPACE_VERSION
     894             : 
     895             :     template<typename _Rep, unsigned long long _Val>
     896             :       struct _Checked_integral_constant
     897             :       : integral_constant<_Rep, static_cast<_Rep>(_Val)>
     898             :       {
     899             :         static_assert(_Checked_integral_constant::value >= 0
     900             :                       && _Checked_integral_constant::value == _Val,
     901             :                       "literal value cannot be represented by duration type");
     902             :       };
     903             : 
     904             :     template<typename _Dur, char... _Digits>
     905           5 :       constexpr _Dur __check_overflow()
     906             :       {
     907             :         using _Val = __parse_int::_Parse_int<_Digits...>;
     908             :         using _Rep = typename _Dur::rep;
     909             :         // TODO: should be simply integral_constant<_Rep, _Val::value>
     910             :         // but GCC doesn't reject narrowing conversions to _Rep.
     911             :         using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>;
     912           5 :         return _Dur{_CheckedVal::value};
     913             :       }
     914             : 
     915             :     constexpr chrono::duration<long double, ratio<3600,1>>
     916             :     operator""h(long double __hours)
     917             :     { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
     918             : 
     919             :     template <char... _Digits>
     920             :       constexpr chrono::hours
     921             :       operator""h()
     922             :       { return __check_overflow<chrono::hours, _Digits...>(); }
     923             : 
     924             :     constexpr chrono::duration<long double, ratio<60,1>>
     925             :     operator""min(long double __mins)
     926             :     { return chrono::duration<long double, ratio<60,1>>{__mins}; }
     927             : 
     928             :     template <char... _Digits>
     929             :       constexpr chrono::minutes
     930             :       operator""min()
     931             :       { return __check_overflow<chrono::minutes, _Digits...>(); }
     932             : 
     933             :     constexpr chrono::duration<long double>
     934             :     operator""s(long double __secs)
     935             :     { return chrono::duration<long double>{__secs}; }
     936             : 
     937             :     template <char... _Digits>
     938             :       constexpr chrono::seconds
     939             :       operator""s()
     940             :       { return __check_overflow<chrono::seconds, _Digits...>(); }
     941             : 
     942             :     constexpr chrono::duration<long double, milli>
     943             :     operator""ms(long double __msecs)
     944             :     { return chrono::duration<long double, milli>{__msecs}; }
     945             : 
     946             :     template <char... _Digits>
     947             :       constexpr chrono::milliseconds
     948           5 :       operator""ms()
     949           5 :       { return __check_overflow<chrono::milliseconds, _Digits...>(); }
     950             : 
     951             :     constexpr chrono::duration<long double, micro>
     952             :     operator""us(long double __usecs)
     953             :     { return chrono::duration<long double, micro>{__usecs}; }
     954             : 
     955             :     template <char... _Digits>
     956             :       constexpr chrono::microseconds
     957             :       operator""us()
     958             :       { return __check_overflow<chrono::microseconds, _Digits...>(); }
     959             : 
     960             :     constexpr chrono::duration<long double, nano>
     961             :     operator""ns(long double __nsecs)
     962             :     { return chrono::duration<long double, nano>{__nsecs}; }
     963             : 
     964             :     template <char... _Digits>
     965             :       constexpr chrono::nanoseconds
     966             :       operator""ns()
     967             :       { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
     968             : 
     969             :   _GLIBCXX_END_NAMESPACE_VERSION
     970             :   } // inline namespace chrono_literals
     971             :   } // inline namespace literals
     972             : 
     973             :   namespace chrono
     974             :   {
     975             :   _GLIBCXX_BEGIN_NAMESPACE_VERSION
     976             : 
     977             :   using namespace literals::chrono_literals;
     978             : 
     979             :   _GLIBCXX_END_NAMESPACE_VERSION
     980             :   } // namespace chrono
     981             : 
     982             : #endif // __cplusplus > 201103L
     983             : 
     984             :   // @} group chrono
     985             : } // namespace std
     986             : 
     987             : #endif //_GLIBCXX_USE_C99_STDINT_TR1
     988             : 
     989             : #endif // C++11
     990             : 
     991             : #endif //_GLIBCXX_CHRONO

Generated by: LCOV version 1.13