| // <chrono> -*- C++ -*- |
| |
| // Copyright (C) 2008-2019 Free Software Foundation, Inc. |
| // |
| // This file is part of the GNU ISO C++ Library. This library is free |
| // software; you can redistribute it and/or modify it under the |
| // terms of the GNU General Public License as published by the |
| // Free Software Foundation; either version 3, or (at your option) |
| // any later version. |
| |
| // This library is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| // Under Section 7 of GPL version 3, you are granted additional |
| // permissions described in the GCC Runtime Library Exception, version |
| // 3.1, as published by the Free Software Foundation. |
| |
| // You should have received a copy of the GNU General Public License and |
| // a copy of the GCC Runtime Library Exception along with this program; |
| // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
| // <http://www.gnu.org/licenses/>. |
| |
| /** @file include/chrono |
| * This is a Standard C++ Library header. |
| */ |
| |
| #ifndef _GLIBCXX_CHRONO |
| #define _GLIBCXX_CHRONO 1 |
| |
| #pragma GCC system_header |
| |
| #if __cplusplus < 201103L |
| # include <bits/c++0x_warning.h> |
| #else |
| |
| #include <ratio> |
| #include <type_traits> |
| #include <limits> |
| #include <ctime> |
| #include <bits/parse_numbers.h> // for literals support. |
| |
| namespace std _GLIBCXX_VISIBILITY(default) |
| { |
| _GLIBCXX_BEGIN_NAMESPACE_VERSION |
| |
| /** |
| * @defgroup chrono Time |
| * @ingroup utilities |
| * |
| * Classes and functions for time. |
| * @{ |
| */ |
| |
| /** @namespace std::chrono |
| * @brief ISO C++ 2011 entities sub-namespace for time and date. |
| */ |
| namespace chrono |
| { |
| template<typename _Rep, typename _Period = ratio<1>> |
| struct duration; |
| |
| template<typename _Clock, typename _Dur = typename _Clock::duration> |
| struct time_point; |
| } |
| |
| // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) |
| |
| template<typename _CT, typename _Period1, typename _Period2> |
| struct __duration_common_type_wrapper |
| { |
| private: |
| typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num; |
| typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den; |
| typedef typename _CT::type __cr; |
| typedef ratio<__gcd_num::value, |
| (_Period1::den / __gcd_den::value) * _Period2::den> __r; |
| public: |
| typedef __success_type<chrono::duration<__cr, __r>> type; |
| }; |
| |
| template<typename _Period1, typename _Period2> |
| struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2> |
| { typedef __failure_type type; }; |
| |
| template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2> |
| struct common_type<chrono::duration<_Rep1, _Period1>, |
| chrono::duration<_Rep2, _Period2>> |
| : public __duration_common_type_wrapper<typename __member_type_wrapper< |
| common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type |
| { }; |
| |
| // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) |
| |
| template<typename _CT, typename _Clock> |
| struct __timepoint_common_type_wrapper |
| { |
| typedef __success_type<chrono::time_point<_Clock, typename _CT::type>> |
| type; |
| }; |
| |
| template<typename _Clock> |
| struct __timepoint_common_type_wrapper<__failure_type, _Clock> |
| { typedef __failure_type type; }; |
| |
| template<typename _Clock, typename _Duration1, typename _Duration2> |
| struct common_type<chrono::time_point<_Clock, _Duration1>, |
| chrono::time_point<_Clock, _Duration2>> |
| : public __timepoint_common_type_wrapper<typename __member_type_wrapper< |
| common_type<_Duration1, _Duration2>>::type, _Clock>::type |
| { }; |
| |
| namespace chrono |
| { |
| // Primary template for duration_cast impl. |
| template<typename _ToDur, typename _CF, typename _CR, |
| bool _NumIsOne = false, bool _DenIsOne = false> |
| struct __duration_cast_impl |
| { |
| template<typename _Rep, typename _Period> |
| static constexpr _ToDur |
| __cast(const duration<_Rep, _Period>& __d) |
| { |
| typedef typename _ToDur::rep __to_rep; |
| return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) |
| * static_cast<_CR>(_CF::num) |
| / static_cast<_CR>(_CF::den))); |
| } |
| }; |
| |
| template<typename _ToDur, typename _CF, typename _CR> |
| struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> |
| { |
| template<typename _Rep, typename _Period> |
| static constexpr _ToDur |
| __cast(const duration<_Rep, _Period>& __d) |
| { |
| typedef typename _ToDur::rep __to_rep; |
| return _ToDur(static_cast<__to_rep>(__d.count())); |
| } |
| }; |
| |
| template<typename _ToDur, typename _CF, typename _CR> |
| struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> |
| { |
| template<typename _Rep, typename _Period> |
| static constexpr _ToDur |
| __cast(const duration<_Rep, _Period>& __d) |
| { |
| typedef typename _ToDur::rep __to_rep; |
| return _ToDur(static_cast<__to_rep>( |
| static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); |
| } |
| }; |
| |
| template<typename _ToDur, typename _CF, typename _CR> |
| struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> |
| { |
| template<typename _Rep, typename _Period> |
| static constexpr _ToDur |
| __cast(const duration<_Rep, _Period>& __d) |
| { |
| typedef typename _ToDur::rep __to_rep; |
| return _ToDur(static_cast<__to_rep>( |
| static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); |
| } |
| }; |
| |
| template<typename _Tp> |
| struct __is_duration |
| : std::false_type |
| { }; |
| |
| template<typename _Rep, typename _Period> |
| struct __is_duration<duration<_Rep, _Period>> |
| : std::true_type |
| { }; |
| |
| template<typename _Tp> |
| using __enable_if_is_duration |
| = typename enable_if<__is_duration<_Tp>::value, _Tp>::type; |
| |
| template<typename _Tp> |
| using __disable_if_is_duration |
| = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type; |
| |
| /// duration_cast |
| template<typename _ToDur, typename _Rep, typename _Period> |
| constexpr __enable_if_is_duration<_ToDur> |
| duration_cast(const duration<_Rep, _Period>& __d) |
| { |
| typedef typename _ToDur::period __to_period; |
| typedef typename _ToDur::rep __to_rep; |
| typedef ratio_divide<_Period, __to_period> __cf; |
| typedef typename common_type<__to_rep, _Rep, intmax_t>::type |
| __cr; |
| typedef __duration_cast_impl<_ToDur, __cf, __cr, |
| __cf::num == 1, __cf::den == 1> __dc; |
| return __dc::__cast(__d); |
| } |
| |
| /// treat_as_floating_point |
| template<typename _Rep> |
| struct treat_as_floating_point |
| : is_floating_point<_Rep> |
| { }; |
| |
| #if __cplusplus > 201402L |
| template <typename _Rep> |
| inline constexpr bool treat_as_floating_point_v = |
| treat_as_floating_point<_Rep>::value; |
| #endif // C++17 |
| |
| #if __cplusplus >= 201703L |
| # define __cpp_lib_chrono 201611 |
| |
| template<typename _ToDur, typename _Rep, typename _Period> |
| constexpr __enable_if_is_duration<_ToDur> |
| floor(const duration<_Rep, _Period>& __d) |
| { |
| auto __to = chrono::duration_cast<_ToDur>(__d); |
| if (__to > __d) |
| return __to - _ToDur{1}; |
| return __to; |
| } |
| |
| template<typename _ToDur, typename _Rep, typename _Period> |
| constexpr __enable_if_is_duration<_ToDur> |
| ceil(const duration<_Rep, _Period>& __d) |
| { |
| auto __to = chrono::duration_cast<_ToDur>(__d); |
| if (__to < __d) |
| return __to + _ToDur{1}; |
| return __to; |
| } |
| |
| template <typename _ToDur, typename _Rep, typename _Period> |
| constexpr enable_if_t< |
| __and_<__is_duration<_ToDur>, |
| __not_<treat_as_floating_point<typename _ToDur::rep>>>::value, |
| _ToDur> |
| round(const duration<_Rep, _Period>& __d) |
| { |
| _ToDur __t0 = chrono::floor<_ToDur>(__d); |
| _ToDur __t1 = __t0 + _ToDur{1}; |
| auto __diff0 = __d - __t0; |
| auto __diff1 = __t1 - __d; |
| if (__diff0 == __diff1) |
| { |
| if (__t0.count() & 1) |
| return __t1; |
| return __t0; |
| } |
| else if (__diff0 < __diff1) |
| return __t0; |
| return __t1; |
| } |
| |
| template<typename _Rep, typename _Period> |
| constexpr |
| enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>> |
| abs(duration<_Rep, _Period> __d) |
| { |
| if (__d >= __d.zero()) |
| return __d; |
| return -__d; |
| } |
| #endif // C++17 |
| |
| /// duration_values |
| template<typename _Rep> |
| struct duration_values |
| { |
| static constexpr _Rep |
| zero() noexcept |
| { return _Rep(0); } |
| |
| static constexpr _Rep |
| max() noexcept |
| { return numeric_limits<_Rep>::max(); } |
| |
| static constexpr _Rep |
| min() noexcept |
| { return numeric_limits<_Rep>::lowest(); } |
| }; |
| |
| template<typename _Tp> |
| struct __is_ratio |
| : std::false_type |
| { }; |
| |
| template<intmax_t _Num, intmax_t _Den> |
| struct __is_ratio<ratio<_Num, _Den>> |
| : std::true_type |
| { }; |
| |
| /// duration |
| template<typename _Rep, typename _Period> |
| struct duration |
| { |
| private: |
| template<typename _Rep2> |
| using __is_float = treat_as_floating_point<_Rep2>; |
| |
| // _Period2 is an exact multiple of _Period |
| template<typename _Period2> |
| using __is_harmonic |
| = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>; |
| |
| public: |
| |
| typedef _Rep rep; |
| typedef _Period period; |
| |
| static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); |
| static_assert(__is_ratio<_Period>::value, |
| "period must be a specialization of ratio"); |
| static_assert(_Period::num > 0, "period must be positive"); |
| |
| // 20.11.5.1 construction / copy / destroy |
| constexpr duration() = default; |
| |
| duration(const duration&) = default; |
| |
| // _GLIBCXX_RESOLVE_LIB_DEFECTS |
| // 3050. Conversion specification problem in chrono::duration |
| template<typename _Rep2, typename = _Require< |
| is_convertible<const _Rep2&, rep>, |
| __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>> |
| constexpr explicit duration(const _Rep2& __rep) |
| : __r(static_cast<rep>(__rep)) { } |
| |
| template<typename _Rep2, typename _Period2, typename = _Require< |
| __or_<__is_float<rep>, |
| __and_<__is_harmonic<_Period2>, |
| __not_<__is_float<_Rep2>>>>>> |
| constexpr duration(const duration<_Rep2, _Period2>& __d) |
| : __r(duration_cast<duration>(__d).count()) { } |
| |
| ~duration() = default; |
| duration& operator=(const duration&) = default; |
| |
| // 20.11.5.2 observer |
| constexpr rep |
| count() const |
| { return __r; } |
| |
| // 20.11.5.3 arithmetic |
| constexpr duration |
| operator+() const |
| { return *this; } |
| |
| constexpr duration |
| operator-() const |
| { return duration(-__r); } |
| |
| _GLIBCXX17_CONSTEXPR duration& |
| operator++() |
| { |
| ++__r; |
| return *this; |
| } |
| |
| _GLIBCXX17_CONSTEXPR duration |
| operator++(int) |
| { return duration(__r++); } |
| |
| _GLIBCXX17_CONSTEXPR duration& |
| operator--() |
| { |
| --__r; |
| return *this; |
| } |
| |
| _GLIBCXX17_CONSTEXPR duration |
| operator--(int) |
| { return duration(__r--); } |
| |
| _GLIBCXX17_CONSTEXPR duration& |
| operator+=(const duration& __d) |
| { |
| __r += __d.count(); |
| return *this; |
| } |
| |
| _GLIBCXX17_CONSTEXPR duration& |
| operator-=(const duration& __d) |
| { |
| __r -= __d.count(); |
| return *this; |
| } |
| |
| _GLIBCXX17_CONSTEXPR duration& |
| operator*=(const rep& __rhs) |
| { |
| __r *= __rhs; |
| return *this; |
| } |
| |
| _GLIBCXX17_CONSTEXPR duration& |
| operator/=(const rep& __rhs) |
| { |
| __r /= __rhs; |
| return *this; |
| } |
| |
| // DR 934. |
| template<typename _Rep2 = rep> |
| _GLIBCXX17_CONSTEXPR |
| typename enable_if<!treat_as_floating_point<_Rep2>::value, |
| duration&>::type |
| operator%=(const rep& __rhs) |
| { |
| __r %= __rhs; |
| return *this; |
| } |
| |
| template<typename _Rep2 = rep> |
| _GLIBCXX17_CONSTEXPR |
| typename enable_if<!treat_as_floating_point<_Rep2>::value, |
| duration&>::type |
| operator%=(const duration& __d) |
| { |
| __r %= __d.count(); |
| return *this; |
| } |
| |
| // 20.11.5.4 special values |
| static constexpr duration |
| zero() noexcept |
| { return duration(duration_values<rep>::zero()); } |
| |
| static constexpr duration |
| min() noexcept |
| { return duration(duration_values<rep>::min()); } |
| |
| static constexpr duration |
| max() noexcept |
| { return duration(duration_values<rep>::max()); } |
| |
| private: |
| rep __r; |
| }; |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr typename common_type<duration<_Rep1, _Period1>, |
| duration<_Rep2, _Period2>>::type |
| operator+(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<__dur1,__dur2>::type __cd; |
| return __cd(__cd(__lhs).count() + __cd(__rhs).count()); |
| } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr typename common_type<duration<_Rep1, _Period1>, |
| duration<_Rep2, _Period2>>::type |
| operator-(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<__dur1,__dur2>::type __cd; |
| return __cd(__cd(__lhs).count() - __cd(__rhs).count()); |
| } |
| |
| // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2 |
| // is implicitly convertible to it. |
| // _GLIBCXX_RESOLVE_LIB_DEFECTS |
| // 3050. Conversion specification problem in chrono::duration constructor |
| template<typename _Rep1, typename _Rep2, |
| typename _CRep = typename common_type<_Rep1, _Rep2>::type> |
| using __common_rep_t = typename |
| enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type; |
| |
| template<typename _Rep1, typename _Period, typename _Rep2> |
| constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period> |
| operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) |
| { |
| typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> |
| __cd; |
| return __cd(__cd(__d).count() * __s); |
| } |
| |
| template<typename _Rep1, typename _Rep2, typename _Period> |
| constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period> |
| operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) |
| { return __d * __s; } |
| |
| template<typename _Rep1, typename _Period, typename _Rep2> |
| constexpr |
| duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> |
| operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) |
| { |
| typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> |
| __cd; |
| return __cd(__cd(__d).count() / __s); |
| } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr typename common_type<_Rep1, _Rep2>::type |
| operator/(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<__dur1,__dur2>::type __cd; |
| return __cd(__lhs).count() / __cd(__rhs).count(); |
| } |
| |
| // DR 934. |
| template<typename _Rep1, typename _Period, typename _Rep2> |
| constexpr |
| duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period> |
| operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) |
| { |
| typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> |
| __cd; |
| return __cd(__cd(__d).count() % __s); |
| } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr typename common_type<duration<_Rep1, _Period1>, |
| duration<_Rep2, _Period2>>::type |
| operator%(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<__dur1,__dur2>::type __cd; |
| return __cd(__cd(__lhs).count() % __cd(__rhs).count()); |
| } |
| |
| // comparisons |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr bool |
| operator==(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<__dur1,__dur2>::type __ct; |
| return __ct(__lhs).count() == __ct(__rhs).count(); |
| } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr bool |
| operator<(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<__dur1,__dur2>::type __ct; |
| return __ct(__lhs).count() < __ct(__rhs).count(); |
| } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr bool |
| operator!=(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { return !(__lhs == __rhs); } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr bool |
| operator<=(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { return !(__rhs < __lhs); } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr bool |
| operator>(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { return __rhs < __lhs; } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Rep2, typename _Period2> |
| constexpr bool |
| operator>=(const duration<_Rep1, _Period1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { return !(__lhs < __rhs); } |
| |
| #ifdef _GLIBCXX_USE_C99_STDINT_TR1 |
| # define _GLIBCXX_CHRONO_INT64_T int64_t |
| #elif defined __INT64_TYPE__ |
| # define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__ |
| #else |
| static_assert(std::numeric_limits<unsigned long long>::digits >= 64, |
| "Representation type for nanoseconds must have at least 64 bits"); |
| # define _GLIBCXX_CHRONO_INT64_T long long |
| #endif |
| |
| /// nanoseconds |
| typedef duration<_GLIBCXX_CHRONO_INT64_T, nano> nanoseconds; |
| |
| /// microseconds |
| typedef duration<_GLIBCXX_CHRONO_INT64_T, micro> microseconds; |
| |
| /// milliseconds |
| typedef duration<_GLIBCXX_CHRONO_INT64_T, milli> milliseconds; |
| |
| /// seconds |
| typedef duration<_GLIBCXX_CHRONO_INT64_T> seconds; |
| |
| /// minutes |
| typedef duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>> minutes; |
| |
| /// hours |
| typedef duration<_GLIBCXX_CHRONO_INT64_T, ratio<3600>> hours; |
| |
| #undef _GLIBCXX_CHRONO_INT64_T |
| |
| /// time_point |
| template<typename _Clock, typename _Dur> |
| struct time_point |
| { |
| typedef _Clock clock; |
| typedef _Dur duration; |
| typedef typename duration::rep rep; |
| typedef typename duration::period period; |
| |
| constexpr time_point() : __d(duration::zero()) |
| { } |
| |
| constexpr explicit time_point(const duration& __dur) |
| : __d(__dur) |
| { } |
| |
| // conversions |
| template<typename _Dur2, |
| typename = _Require<is_convertible<_Dur2, _Dur>>> |
| constexpr time_point(const time_point<clock, _Dur2>& __t) |
| : __d(__t.time_since_epoch()) |
| { } |
| |
| // observer |
| constexpr duration |
| time_since_epoch() const |
| { return __d; } |
| |
| // arithmetic |
| _GLIBCXX17_CONSTEXPR time_point& |
| operator+=(const duration& __dur) |
| { |
| __d += __dur; |
| return *this; |
| } |
| |
| _GLIBCXX17_CONSTEXPR time_point& |
| operator-=(const duration& __dur) |
| { |
| __d -= __dur; |
| return *this; |
| } |
| |
| // special values |
| static constexpr time_point |
| min() noexcept |
| { return time_point(duration::min()); } |
| |
| static constexpr time_point |
| max() noexcept |
| { return time_point(duration::max()); } |
| |
| private: |
| duration __d; |
| }; |
| |
| /// time_point_cast |
| template<typename _ToDur, typename _Clock, typename _Dur> |
| constexpr typename enable_if<__is_duration<_ToDur>::value, |
| time_point<_Clock, _ToDur>>::type |
| time_point_cast(const time_point<_Clock, _Dur>& __t) |
| { |
| typedef time_point<_Clock, _ToDur> __time_point; |
| return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); |
| } |
| |
| #if __cplusplus > 201402L |
| template<typename _ToDur, typename _Clock, typename _Dur> |
| constexpr |
| enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> |
| floor(const time_point<_Clock, _Dur>& __tp) |
| { |
| return time_point<_Clock, _ToDur>{ |
| chrono::floor<_ToDur>(__tp.time_since_epoch())}; |
| } |
| |
| template<typename _ToDur, typename _Clock, typename _Dur> |
| constexpr |
| enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>> |
| ceil(const time_point<_Clock, _Dur>& __tp) |
| { |
| return time_point<_Clock, _ToDur>{ |
| chrono::ceil<_ToDur>(__tp.time_since_epoch())}; |
| } |
| |
| template<typename _ToDur, typename _Clock, typename _Dur> |
| constexpr enable_if_t< |
| __and_<__is_duration<_ToDur>, |
| __not_<treat_as_floating_point<typename _ToDur::rep>>>::value, |
| time_point<_Clock, _ToDur>> |
| round(const time_point<_Clock, _Dur>& __tp) |
| { |
| return time_point<_Clock, _ToDur>{ |
| chrono::round<_ToDur>(__tp.time_since_epoch())}; |
| } |
| #endif // C++17 |
| |
| template<typename _Clock, typename _Dur1, |
| typename _Rep2, typename _Period2> |
| constexpr time_point<_Clock, |
| typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> |
| operator+(const time_point<_Clock, _Dur1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<_Dur1,__dur2>::type __ct; |
| typedef time_point<_Clock, __ct> __time_point; |
| return __time_point(__lhs.time_since_epoch() + __rhs); |
| } |
| |
| template<typename _Rep1, typename _Period1, |
| typename _Clock, typename _Dur2> |
| constexpr time_point<_Clock, |
| typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> |
| operator+(const duration<_Rep1, _Period1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { |
| typedef duration<_Rep1, _Period1> __dur1; |
| typedef typename common_type<__dur1,_Dur2>::type __ct; |
| typedef time_point<_Clock, __ct> __time_point; |
| return __time_point(__rhs.time_since_epoch() + __lhs); |
| } |
| |
| template<typename _Clock, typename _Dur1, |
| typename _Rep2, typename _Period2> |
| constexpr time_point<_Clock, |
| typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> |
| operator-(const time_point<_Clock, _Dur1>& __lhs, |
| const duration<_Rep2, _Period2>& __rhs) |
| { |
| typedef duration<_Rep2, _Period2> __dur2; |
| typedef typename common_type<_Dur1,__dur2>::type __ct; |
| typedef time_point<_Clock, __ct> __time_point; |
| return __time_point(__lhs.time_since_epoch() -__rhs); |
| } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr typename common_type<_Dur1, _Dur2>::type |
| operator-(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr bool |
| operator==(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr bool |
| operator!=(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return !(__lhs == __rhs); } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr bool |
| operator<(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr bool |
| operator<=(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return !(__rhs < __lhs); } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr bool |
| operator>(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return __rhs < __lhs; } |
| |
| template<typename _Clock, typename _Dur1, typename _Dur2> |
| constexpr bool |
| operator>=(const time_point<_Clock, _Dur1>& __lhs, |
| const time_point<_Clock, _Dur2>& __rhs) |
| { return !(__lhs < __rhs); } |
| |
| |
| // Clocks. |
| |
| // Why nanosecond resolution as the default? |
| // Why have std::system_clock always count in the highest |
| // resolution (ie nanoseconds), even if on some OSes the low 3 |
| // or 9 decimal digits will be always zero? This allows later |
| // implementations to change the system_clock::now() |
| // implementation any time to provide better resolution without |
| // changing function signature or units. |
| |
| // To support the (forward) evolution of the library's defined |
| // clocks, wrap inside inline namespace so that the current |
| // defintions of system_clock, steady_clock, and |
| // high_resolution_clock types are uniquely mangled. This way, new |
| // code can use the latests clocks, while the library can contain |
| // compatibility definitions for previous versions. At some |
| // point, when these clocks settle down, the inlined namespaces |
| // can be removed. XXX GLIBCXX_ABI Deprecated |
| inline namespace _V2 { |
| |
| /** |
| * @brief System clock. |
| * |
| * Time returned represents wall time from the system-wide clock. |
| */ |
| struct system_clock |
| { |
| typedef chrono::nanoseconds duration; |
| typedef duration::rep rep; |
| typedef duration::period period; |
| typedef chrono::time_point<system_clock, duration> time_point; |
| |
| static_assert(system_clock::duration::min() |
| < system_clock::duration::zero(), |
| "a clock's minimum duration cannot be less than its epoch"); |
| |
| static constexpr bool is_steady = false; |
| |
| static time_point |
| now() noexcept; |
| |
| // Map to C API |
| static std::time_t |
| to_time_t(const time_point& __t) noexcept |
| { |
| return std::time_t(duration_cast<chrono::seconds> |
| (__t.time_since_epoch()).count()); |
| } |
| |
| static time_point |
| from_time_t(std::time_t __t) noexcept |
| { |
| typedef chrono::time_point<system_clock, seconds> __from; |
| return time_point_cast<system_clock::duration> |
| (__from(chrono::seconds(__t))); |
| } |
| }; |
| |
| |
| /** |
| * @brief Monotonic clock |
| * |
| * Time returned has the property of only increasing at a uniform rate. |
| */ |
| struct steady_clock |
| { |
| typedef chrono::nanoseconds duration; |
| typedef duration::rep rep; |
| typedef duration::period period; |
| typedef chrono::time_point<steady_clock, duration> time_point; |
| |
| static constexpr bool is_steady = true; |
| |
| static time_point |
| now() noexcept; |
| }; |
| |
| |
| /** |
| * @brief Highest-resolution clock |
| * |
| * This is the clock "with the shortest tick period." Alias to |
| * std::system_clock until higher-than-nanosecond definitions |
| * become feasible. |
| */ |
| using high_resolution_clock = system_clock; |
| |
| } // end inline namespace _V2 |
| } // namespace chrono |
| |
| #if __cplusplus > 201103L |
| |
| #define __cpp_lib_chrono_udls 201304 |
| |
| inline namespace literals |
| { |
| inline namespace chrono_literals |
| { |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wliteral-suffix" |
| template<typename _Dur, char... _Digits> |
| constexpr _Dur __check_overflow() |
| { |
| using _Val = __parse_int::_Parse_int<_Digits...>; |
| constexpr typename _Dur::rep __repval = _Val::value; |
| static_assert(__repval >= 0 && __repval == _Val::value, |
| "literal value cannot be represented by duration type"); |
| return _Dur(__repval); |
| } |
| |
| constexpr chrono::duration<long double, ratio<3600,1>> |
| operator""h(long double __hours) |
| { return chrono::duration<long double, ratio<3600,1>>{__hours}; } |
| |
| template <char... _Digits> |
| constexpr chrono::hours |
| operator""h() |
| { return __check_overflow<chrono::hours, _Digits...>(); } |
| |
| constexpr chrono::duration<long double, ratio<60,1>> |
| operator""min(long double __mins) |
| { return chrono::duration<long double, ratio<60,1>>{__mins}; } |
| |
| template <char... _Digits> |
| constexpr chrono::minutes |
| operator""min() |
| { return __check_overflow<chrono::minutes, _Digits...>(); } |
| |
| constexpr chrono::duration<long double> |
| operator""s(long double __secs) |
| { return chrono::duration<long double>{__secs}; } |
| |
| template <char... _Digits> |
| constexpr chrono::seconds |
| operator""s() |
| { return __check_overflow<chrono::seconds, _Digits...>(); } |
| |
| constexpr chrono::duration<long double, milli> |
| operator""ms(long double __msecs) |
| { return chrono::duration<long double, milli>{__msecs}; } |
| |
| template <char... _Digits> |
| constexpr chrono::milliseconds |
| operator""ms() |
| { return __check_overflow<chrono::milliseconds, _Digits...>(); } |
| |
| constexpr chrono::duration<long double, micro> |
| operator""us(long double __usecs) |
| { return chrono::duration<long double, micro>{__usecs}; } |
| |
| template <char... _Digits> |
| constexpr chrono::microseconds |
| operator""us() |
| { return __check_overflow<chrono::microseconds, _Digits...>(); } |
| |
| constexpr chrono::duration<long double, nano> |
| operator""ns(long double __nsecs) |
| { return chrono::duration<long double, nano>{__nsecs}; } |
| |
| template <char... _Digits> |
| constexpr chrono::nanoseconds |
| operator""ns() |
| { return __check_overflow<chrono::nanoseconds, _Digits...>(); } |
| |
| #pragma GCC diagnostic pop |
| } // inline namespace chrono_literals |
| } // inline namespace literals |
| |
| namespace chrono |
| { |
| using namespace literals::chrono_literals; |
| } // namespace chrono |
| |
| #endif // C++14 |
| |
| // @} group chrono |
| |
| _GLIBCXX_END_NAMESPACE_VERSION |
| } // namespace std |
| |
| #endif // C++11 |
| |
| #endif //_GLIBCXX_CHRONO |
