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