libcxx/include/__chrono/duration.h

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP___CHRONO_DURATION_H
  11 #define _LIBCPP___CHRONO_DURATION_H
  12
  13 #include <__compare/ordering.h>
  14 #include <__compare/three_way_comparable.h>
  15 #include <__config>
  16 #include <__type_traits/common_type.h>
  17 #include <__type_traits/enable_if.h>
  18 #include <__type_traits/is_convertible.h>
  19 #include <__type_traits/is_floating_point.h>
  20 #include <limits>
  21 #include <ratio>
  22
  23 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  24 #  pragma GCC system_header
  25 #endif
  26
  27 _LIBCPP_PUSH_MACROS
  28 #include <__undef_macros>
  29
  30 _LIBCPP_BEGIN_NAMESPACE_STD
  31
  32 namespace chrono
  33 {
  34
  35 template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
  36
  37 template <class _Tp>
  38 struct __is_duration : false_type {};
  39
  40 template <class _Rep, class _Period>
  41 struct __is_duration<duration<_Rep, _Period> > : true_type  {};
  42
  43 template <class _Rep, class _Period>
  44 struct __is_duration<const duration<_Rep, _Period> > : true_type  {};
  45
  46 template <class _Rep, class _Period>
  47 struct __is_duration<volatile duration<_Rep, _Period> > : true_type  {};
  48
  49 template <class _Rep, class _Period>
  50 struct __is_duration<const volatile duration<_Rep, _Period> > : true_type  {};
  51
  52 } // namespace chrono
  53
  54 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
  55 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
  56                                          chrono::duration<_Rep2, _Period2> >
  57 {
  58     typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
  59                              typename __ratio_gcd<_Period1, _Period2>::type> type;
  60 };
  61
  62 namespace chrono {
  63
  64 // duration_cast
  65
  66 template <class _FromDuration, class _ToDuration,
  67           class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
  68           bool = _Period::num == 1,
  69           bool = _Period::den == 1>
  70 struct __duration_cast;
  71
  72 template <class _FromDuration, class _ToDuration, class _Period>
  73 struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
  74 {
  75     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
  76     _ToDuration operator()(const _FromDuration& __fd) const
  77     {
  78         return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
  79     }
  80 };
  81
  82 template <class _FromDuration, class _ToDuration, class _Period>
  83 struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
  84 {
  85     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
  86     _ToDuration operator()(const _FromDuration& __fd) const
  87     {
  88         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
  89         return _ToDuration(static_cast<typename _ToDuration::rep>(
  90                            static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
  91     }
  92 };
  93
  94 template <class _FromDuration, class _ToDuration, class _Period>
  95 struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
  96 {
  97     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
  98     _ToDuration operator()(const _FromDuration& __fd) const
  99     {
 100         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
 101         return _ToDuration(static_cast<typename _ToDuration::rep>(
 102                            static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
 103     }
 104 };
 105
 106 template <class _FromDuration, class _ToDuration, class _Period>
 107 struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
 108 {
 109     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 110     _ToDuration operator()(const _FromDuration& __fd) const
 111     {
 112         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
 113         return _ToDuration(static_cast<typename _ToDuration::rep>(
 114                            static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
 115                                                           / static_cast<_Ct>(_Period::den)));
 116     }
 117 };
 118
 119 template <class _ToDuration, class _Rep, class _Period, __enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 120 inline _LIBCPP_INLINE_VISIBILITY
 121 _LIBCPP_CONSTEXPR
 122 _ToDuration
 123 duration_cast(const duration<_Rep, _Period>& __fd)
 124 {
 125     return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
 126 }
 127
 128 template <class _Rep>
 129 struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
 130
 131 #if _LIBCPP_STD_VER >= 17
 132 template <class _Rep>
 133 inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
 134 #endif
 135
 136 template <class _Rep>
 137 struct _LIBCPP_TEMPLATE_VIS duration_values
 138 {
 139 public:
 140     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
 141     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  _NOEXCEPT {return numeric_limits<_Rep>::max();}
 142     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
 143 };
 144
 145 #if _LIBCPP_STD_VER >= 17
 146 template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 147 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 148 _ToDuration
 149 floor(const duration<_Rep, _Period>& __d)
 150 {
 151     _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
 152     if (__t > __d)
 153         __t = __t - _ToDuration{1};
 154     return __t;
 155 }
 156
 157 template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 158 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 159 _ToDuration
 160 ceil(const duration<_Rep, _Period>& __d)
 161 {
 162     _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
 163     if (__t < __d)
 164         __t = __t + _ToDuration{1};
 165     return __t;
 166 }
 167
 168 template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
 169 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 170 _ToDuration
 171 round(const duration<_Rep, _Period>& __d)
 172 {
 173     _ToDuration __lower = chrono::floor<_ToDuration>(__d);
 174     _ToDuration __upper = __lower + _ToDuration{1};
 175     auto __lower_diff   = __d - __lower;
 176     auto __upper_diff   = __upper - __d;
 177     if (__lower_diff < __upper_diff)
 178         return __lower;
 179     if (__lower_diff > __upper_diff)
 180         return __upper;
 181     return __lower.count() & 1 ? __upper : __lower;
 182 }
 183 #endif
 184
 185 // duration
 186
 187 template <class _Rep, class _Period>
 188 class _LIBCPP_TEMPLATE_VIS duration
 189 {
 190     static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
 191     static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
 192     static_assert(_Period::num > 0, "duration period must be positive");
 193
 194     template <class _R1, class _R2>
 195     struct __no_overflow
 196     {
 197     private:
 198         static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
 199         static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 200         static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
 201         static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
 202         static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
 203         static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
 204         static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
 205
 206         template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
 207         struct __mul    // __overflow == false
 208         {
 209             static const intmax_t value = _Xp * _Yp;
 210         };
 211
 212         template <intmax_t _Xp, intmax_t _Yp>
 213         struct __mul<_Xp, _Yp, true>
 214         {
 215             static const intmax_t value = 1;
 216         };
 217
 218     public:
 219         static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
 220         typedef ratio<__mul<__n1, __d2, !value>::value,
 221                       __mul<__n2, __d1, !value>::value> type;
 222     };
 223
 224 public:
 225     typedef _Rep rep;
 226     typedef typename _Period::type period;
 227 private:
 228     rep __rep_;
 229 public:
 230
 231 #ifndef _LIBCPP_CXX03_LANG
 232         constexpr duration() = default;
 233 #else
 234         _LIBCPP_HIDE_FROM_ABI duration() {}
 235 #endif
 236
 237     template <class _Rep2, __enable_if_t<is_convertible<const _Rep2&, rep>::value &&
 238                                          (treat_as_floating_point<rep>::value ||
 239                                           !treat_as_floating_point<_Rep2>::value), int> = 0>
 240         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 241         explicit duration(const _Rep2& __r)
 242                 : __rep_(__r) {}
 243
 244     // conversions
 245     template <class _Rep2, class _Period2, __enable_if_t<__no_overflow<_Period2, period>::value && (
 246                                                             treat_as_floating_point<rep>::value ||
 247                                                             (__no_overflow<_Period2, period>::type::den == 1 &&
 248                                                              !treat_as_floating_point<_Rep2>::value)), int> = 0>
 249         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 250         duration(const duration<_Rep2, _Period2>& __d)
 251                 : __rep_(chrono::duration_cast<duration>(__d).count()) {}
 252
 253     // observer
 254
 255     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
 256
 257     // arithmetic
 258
 259     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
 260     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
 261     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator++()      {++__rep_; return *this;}
 262     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration  operator++(int)   {return duration(__rep_++);}
 263     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator--()      {--__rep_; return *this;}
 264     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration  operator--(int)   {return duration(__rep_--);}
 265
 266     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
 267     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
 268
 269     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator*=(const rep& __rhs) {__rep_ *= __rhs; return *this;}
 270     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator/=(const rep& __rhs) {__rep_ /= __rhs; return *this;}
 271     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator%=(const rep& __rhs) {__rep_ %= __rhs; return *this;}
 272     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator%=(const duration& __rhs) {__rep_ %= __rhs.count(); return *this;}
 273
 274     // special values
 275
 276     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
 277     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  _NOEXCEPT {return duration(duration_values<rep>::min());}
 278     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  _NOEXCEPT {return duration(duration_values<rep>::max());}
 279 };
 280
 281 typedef duration<long long,         nano> nanoseconds;
 282 typedef duration<long long,        micro> microseconds;
 283 typedef duration<long long,        milli> milliseconds;
 284 typedef duration<long long              > seconds;
 285 typedef duration<     long, ratio<  60> > minutes;
 286 typedef duration<     long, ratio<3600> > hours;
 287 #if _LIBCPP_STD_VER >= 20
 288 typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
 289 typedef duration<     int, ratio_multiply<ratio<7>,   days::period>>         weeks;
 290 typedef duration<     int, ratio_multiply<ratio<146097, 400>, days::period>> years;
 291 typedef duration<     int, ratio_divide<years::period, ratio<12>>>           months;
 292 #endif
 293 // Duration ==
 294
 295 template <class _LhsDuration, class _RhsDuration>
 296 struct __duration_eq
 297 {
 298     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 299     bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
 300         {
 301             typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
 302             return _Ct(__lhs).count() == _Ct(__rhs).count();
 303         }
 304 };
 305
 306 template <class _LhsDuration>
 307 struct __duration_eq<_LhsDuration, _LhsDuration>
 308 {
 309     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 310     bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
 311         {return __lhs.count() == __rhs.count();}
 312 };
 313
 314 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 315 inline _LIBCPP_INLINE_VISIBILITY
 316 _LIBCPP_CONSTEXPR
 317 bool
 318 operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 319 {
 320     return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 321 }
 322
 323 #if _LIBCPP_STD_VER <= 17
 324
 325 // Duration !=
 326
 327 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 328 inline _LIBCPP_INLINE_VISIBILITY
 329 _LIBCPP_CONSTEXPR
 330 bool
 331 operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 332 {
 333     return !(__lhs == __rhs);
 334 }
 335
 336 #endif // _LIBCPP_STD_VER <= 17
 337
 338 // Duration <
 339
 340 template <class _LhsDuration, class _RhsDuration>
 341 struct __duration_lt
 342 {
 343     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 344     bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
 345         {
 346             typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
 347             return _Ct(__lhs).count() < _Ct(__rhs).count();
 348         }
 349 };
 350
 351 template <class _LhsDuration>
 352 struct __duration_lt<_LhsDuration, _LhsDuration>
 353 {
 354     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 355     bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
 356         {return __lhs.count() < __rhs.count();}
 357 };
 358
 359 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 360 inline _LIBCPP_INLINE_VISIBILITY
 361 _LIBCPP_CONSTEXPR
 362 bool
 363 operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 364 {
 365     return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 366 }
 367
 368 // Duration >
 369
 370 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 371 inline _LIBCPP_INLINE_VISIBILITY
 372 _LIBCPP_CONSTEXPR
 373 bool
 374 operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 375 {
 376     return __rhs < __lhs;
 377 }
 378
 379 // Duration <=
 380
 381 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 382 inline _LIBCPP_INLINE_VISIBILITY
 383 _LIBCPP_CONSTEXPR
 384 bool
 385 operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 386 {
 387     return !(__rhs < __lhs);
 388 }
 389
 390 // Duration >=
 391
 392 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 393 inline _LIBCPP_INLINE_VISIBILITY
 394 _LIBCPP_CONSTEXPR
 395 bool
 396 operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 397 {
 398     return !(__lhs < __rhs);
 399 }
 400
 401 #if _LIBCPP_STD_VER >= 20
 402
 403 template<class _Rep1, class _Period1, class _Rep2, class _Period2>
 404   requires three_way_comparable<common_type_t<_Rep1, _Rep2>>
 405 _LIBCPP_HIDE_FROM_ABI
 406 constexpr auto operator<=>(const duration<_Rep1, _Period1>& __lhs,
 407                            const duration<_Rep2, _Period2>& __rhs)
 408 {
 409     using _Ct = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
 410     return _Ct(__lhs).count() <=> _Ct(__rhs).count();
 411 }
 412
 413 #endif // _LIBCPP_STD_VER >= 20
 414
 415 // Duration +
 416
 417 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 418 inline _LIBCPP_INLINE_VISIBILITY
 419 _LIBCPP_CONSTEXPR
 420 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 421 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 422 {
 423     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 424     return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
 425 }
 426
 427 // Duration -
 428
 429 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 430 inline _LIBCPP_INLINE_VISIBILITY
 431 _LIBCPP_CONSTEXPR
 432 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 433 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 434 {
 435     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 436     return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
 437 }
 438
 439 // Duration *
 440
 441 template <class _Rep1, class _Period, class _Rep2,
 442           __enable_if_t<is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 443 inline _LIBCPP_INLINE_VISIBILITY
 444 _LIBCPP_CONSTEXPR
 445 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 446 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 447 {
 448     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 449     typedef duration<_Cr, _Period> _Cd;
 450     return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
 451 }
 452
 453 template <class _Rep1, class _Period, class _Rep2,
 454           __enable_if_t<is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 455 inline _LIBCPP_INLINE_VISIBILITY
 456 _LIBCPP_CONSTEXPR
 457 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 458 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
 459 {
 460     return __d * __s;
 461 }
 462
 463 // Duration /
 464
 465 template <class _Rep1, class _Period, class _Rep2,
 466           __enable_if_t<!__is_duration<_Rep2>::value && is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 467 inline _LIBCPP_INLINE_VISIBILITY
 468 _LIBCPP_CONSTEXPR
 469 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 470 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 471 {
 472     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 473     typedef duration<_Cr, _Period> _Cd;
 474     return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
 475 }
 476
 477 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 478 inline _LIBCPP_INLINE_VISIBILITY
 479 _LIBCPP_CONSTEXPR
 480 typename common_type<_Rep1, _Rep2>::type
 481 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 482 {
 483     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
 484     return _Ct(__lhs).count() / _Ct(__rhs).count();
 485 }
 486
 487 // Duration %
 488
 489 template <class _Rep1, class _Period, class _Rep2,
 490           __enable_if_t<!__is_duration<_Rep2>::value && is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
 491 inline _LIBCPP_INLINE_VISIBILITY
 492 _LIBCPP_CONSTEXPR
 493 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 494 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 495 {
 496     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 497     typedef duration<_Cr, _Period> _Cd;
 498     return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
 499 }
 500
 501 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 502 inline _LIBCPP_INLINE_VISIBILITY
 503 _LIBCPP_CONSTEXPR
 504 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 505 operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 506 {
 507     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 508     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 509     return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
 510 }
 511
 512 } // namespace chrono
 513
 514 #if _LIBCPP_STD_VER >= 14
 515 // Suffixes for duration literals [time.duration.literals]
 516 inline namespace literals
 517 {
 518   inline namespace chrono_literals
 519   {
 520
 521     _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h)
 522     {
 523         return chrono::hours(static_cast<chrono::hours::rep>(__h));
 524     }
 525
 526     _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
 527     {
 528         return chrono::duration<long double, ratio<3600,1>>(__h);
 529     }
 530
 531
 532     _LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes operator""min(unsigned long long __m)
 533     {
 534         return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
 535     }
 536
 537     _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
 538     {
 539         return chrono::duration<long double, ratio<60,1>> (__m);
 540     }
 541
 542
 543     _LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds operator""s(unsigned long long __s)
 544     {
 545         return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
 546     }
 547
 548     _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double> operator""s(long double __s)
 549     {
 550         return chrono::duration<long double> (__s);
 551     }
 552
 553
 554     _LIBCPP_HIDE_FROM_ABI constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
 555     {
 556         return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
 557     }
 558
 559     _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
 560     {
 561         return chrono::duration<long double, milli>(__ms);
 562     }
 563
 564
 565     _LIBCPP_HIDE_FROM_ABI constexpr chrono::microseconds operator""us(unsigned long long __us)
 566     {
 567         return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
 568     }
 569
 570     _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, micro> operator""us(long double __us)
 571     {
 572         return chrono::duration<long double, micro> (__us);
 573     }
 574
 575
 576     _LIBCPP_HIDE_FROM_ABI constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
 577     {
 578         return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
 579     }
 580
 581     _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
 582     {
 583         return chrono::duration<long double, nano> (__ns);
 584     }
 585
 586 } // namespace chrono_literals
 587 } // namespace literals
 588
 589 namespace chrono { // hoist the literals into namespace std::chrono
 590    using namespace literals::chrono_literals;
 591 } // namespace chrono
 592
 593 #endif // _LIBCPP_STD_VER >= 14
 594
 595 _LIBCPP_END_NAMESPACE_STD
 596
 597 _LIBCPP_POP_MACROS
 598
 599 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 600 #  include <type_traits>
 601 #endif
 602
 603 #endif // _LIBCPP___CHRONO_DURATION_H