1// -*- C++ -*- 2//===---------------------------- chrono ----------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_CHRONO 12#define _LIBCPP_CHRONO 13 14/* 15 chrono synopsis 16 17namespace std 18{ 19namespace chrono 20{ 21 22template <class ToDuration, class Rep, class Period> 23constexpr 24ToDuration 25duration_cast(const duration<Rep, Period>& fd); 26 27template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {}; 28 29template <class Rep> constexpr bool treat_as_floating_point_v 30 = treat_as_floating_point<Rep>::value; // C++17 31 32template <class Rep> 33struct duration_values 34{ 35public: 36 static constexpr Rep zero(); 37 static constexpr Rep max(); 38 static constexpr Rep min(); 39}; 40 41// duration 42 43template <class Rep, class Period = ratio<1>> 44class duration 45{ 46 static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration"); 47 static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio"); 48 static_assert(Period::num > 0, "duration period must be positive"); 49public: 50 typedef Rep rep; 51 typedef Period period; 52 53 constexpr duration() = default; 54 template <class Rep2> 55 constexpr explicit duration(const Rep2& r, 56 typename enable_if 57 < 58 is_convertible<Rep2, rep>::value && 59 (treat_as_floating_point<rep>::value || 60 !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value) 61 >::type* = 0); 62 63 // conversions 64 template <class Rep2, class Period2> 65 constexpr duration(const duration<Rep2, Period2>& d, 66 typename enable_if 67 < 68 treat_as_floating_point<rep>::value || 69 ratio_divide<Period2, period>::type::den == 1 70 >::type* = 0); 71 72 // observer 73 74 constexpr rep count() const; 75 76 // arithmetic 77 78 constexpr duration operator+() const; 79 constexpr duration operator-() const; 80 constexpr duration& operator++(); 81 constexpr duration operator++(int); 82 constexpr duration& operator--(); 83 constexpr duration operator--(int); 84 85 constexpr duration& operator+=(const duration& d); 86 constexpr duration& operator-=(const duration& d); 87 88 duration& operator*=(const rep& rhs); 89 duration& operator/=(const rep& rhs); 90 91 // special values 92 93 static constexpr duration zero(); 94 static constexpr duration min(); 95 static constexpr duration max(); 96}; 97 98typedef duration<long long, nano> nanoseconds; 99typedef duration<long long, micro> microseconds; 100typedef duration<long long, milli> milliseconds; 101typedef duration<long long > seconds; 102typedef duration< long, ratio< 60> > minutes; 103typedef duration< long, ratio<3600> > hours; 104 105template <class Clock, class Duration = typename Clock::duration> 106class time_point 107{ 108public: 109 typedef Clock clock; 110 typedef Duration duration; 111 typedef typename duration::rep rep; 112 typedef typename duration::period period; 113private: 114 duration d_; // exposition only 115 116public: 117 time_point(); // has value "epoch" // constexpr in C++14 118 explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14 119 120 // conversions 121 template <class Duration2> 122 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14 123 124 // observer 125 126 duration time_since_epoch() const; // constexpr in C++14 127 128 // arithmetic 129 130 time_point& operator+=(const duration& d); 131 time_point& operator-=(const duration& d); 132 133 // special values 134 135 static constexpr time_point min(); 136 static constexpr time_point max(); 137}; 138 139} // chrono 140 141// common_type traits 142template <class Rep1, class Period1, class Rep2, class Period2> 143 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>; 144 145template <class Clock, class Duration1, class Duration2> 146 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>; 147 148namespace chrono { 149 150// duration arithmetic 151template <class Rep1, class Period1, class Rep2, class Period2> 152 constexpr 153 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type 154 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 155template <class Rep1, class Period1, class Rep2, class Period2> 156 constexpr 157 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type 158 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 159template <class Rep1, class Period, class Rep2> 160 constexpr 161 duration<typename common_type<Rep1, Rep2>::type, Period> 162 operator*(const duration<Rep1, Period>& d, const Rep2& s); 163template <class Rep1, class Period, class Rep2> 164 constexpr 165 duration<typename common_type<Rep1, Rep2>::type, Period> 166 operator*(const Rep1& s, const duration<Rep2, Period>& d); 167template <class Rep1, class Period, class Rep2> 168 constexpr 169 duration<typename common_type<Rep1, Rep2>::type, Period> 170 operator/(const duration<Rep1, Period>& d, const Rep2& s); 171template <class Rep1, class Period1, class Rep2, class Period2> 172 constexpr 173 typename common_type<Rep1, Rep2>::type 174 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 175 176// duration comparisons 177template <class Rep1, class Period1, class Rep2, class Period2> 178 constexpr 179 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 180template <class Rep1, class Period1, class Rep2, class Period2> 181 constexpr 182 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 183template <class Rep1, class Period1, class Rep2, class Period2> 184 constexpr 185 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 186template <class Rep1, class Period1, class Rep2, class Period2> 187 constexpr 188 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 189template <class Rep1, class Period1, class Rep2, class Period2> 190 constexpr 191 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 192template <class Rep1, class Period1, class Rep2, class Period2> 193 constexpr 194 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 195 196// duration_cast 197template <class ToDuration, class Rep, class Period> 198 ToDuration duration_cast(const duration<Rep, Period>& d); 199 200template <class ToDuration, class Rep, class Period> 201 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17 202template <class ToDuration, class Rep, class Period> 203 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17 204template <class ToDuration, class Rep, class Period> 205 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17 206 207// time_point arithmetic (all constexpr in C++14) 208template <class Clock, class Duration1, class Rep2, class Period2> 209 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type> 210 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); 211template <class Rep1, class Period1, class Clock, class Duration2> 212 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type> 213 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs); 214template <class Clock, class Duration1, class Rep2, class Period2> 215 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type> 216 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); 217template <class Clock, class Duration1, class Duration2> 218 typename common_type<Duration1, Duration2>::type 219 operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 220 221// time_point comparisons (all constexpr in C++14) 222template <class Clock, class Duration1, class Duration2> 223 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 224template <class Clock, class Duration1, class Duration2> 225 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 226template <class Clock, class Duration1, class Duration2> 227 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 228template <class Clock, class Duration1, class Duration2> 229 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 230template <class Clock, class Duration1, class Duration2> 231 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 232template <class Clock, class Duration1, class Duration2> 233 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 234 235// time_point_cast (constexpr in C++14) 236 237template <class ToDuration, class Clock, class Duration> 238 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t); 239 240template <class ToDuration, class Clock, class Duration> 241 constexpr time_point<Clock, ToDuration> 242 floor(const time_point<Clock, Duration>& tp); // C++17 243 244template <class ToDuration, class Clock, class Duration> 245 constexpr time_point<Clock, ToDuration> 246 ceil(const time_point<Clock, Duration>& tp); // C++17 247 248template <class ToDuration, class Clock, class Duration> 249 constexpr time_point<Clock, ToDuration> 250 round(const time_point<Clock, Duration>& tp); // C++17 251 252template <class Rep, class Period> 253 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17 254// Clocks 255 256class system_clock 257{ 258public: 259 typedef microseconds duration; 260 typedef duration::rep rep; 261 typedef duration::period period; 262 typedef chrono::time_point<system_clock> time_point; 263 static const bool is_steady = false; // constexpr in C++14 264 265 static time_point now() noexcept; 266 static time_t to_time_t (const time_point& __t) noexcept; 267 static time_point from_time_t(time_t __t) noexcept; 268}; 269 270class steady_clock 271{ 272public: 273 typedef nanoseconds duration; 274 typedef duration::rep rep; 275 typedef duration::period period; 276 typedef chrono::time_point<steady_clock, duration> time_point; 277 static const bool is_steady = true; // constexpr in C++14 278 279 static time_point now() noexcept; 280}; 281 282typedef steady_clock high_resolution_clock; 283 284} // chrono 285 286constexpr chrono::hours operator "" h(unsigned long long); // C++14 287constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long double); // C++14 288constexpr chrono::minutes operator "" min(unsigned long long); // C++14 289constexpr chrono::duration<unspecified , ratio<60,1>> operator "" min(long double); // C++14 290constexpr chrono::seconds operator "" s(unsigned long long); // C++14 291constexpr chrono::duration<unspecified > operator "" s(long double); // C++14 292constexpr chrono::milliseconds operator "" ms(unsigned long long); // C++14 293constexpr chrono::duration<unspecified , milli> operator "" ms(long double); // C++14 294constexpr chrono::microseconds operator "" us(unsigned long long); // C++14 295constexpr chrono::duration<unspecified , micro> operator "" us(long double); // C++14 296constexpr chrono::nanoseconds operator "" ns(unsigned long long); // C++14 297constexpr chrono::duration<unspecified , nano> operator "" ns(long double); // C++14 298 299} // std 300*/ 301 302#include <__config> 303#include <ctime> 304#include <type_traits> 305#include <ratio> 306#include <limits> 307 308#include <__undef_min_max> 309 310#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 311#pragma GCC system_header 312#endif 313 314_LIBCPP_BEGIN_NAMESPACE_STD 315 316namespace chrono 317{ 318 319template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration; 320 321template <class _Tp> 322struct __is_duration : false_type {}; 323 324template <class _Rep, class _Period> 325struct __is_duration<duration<_Rep, _Period> > : true_type {}; 326 327template <class _Rep, class _Period> 328struct __is_duration<const duration<_Rep, _Period> > : true_type {}; 329 330template <class _Rep, class _Period> 331struct __is_duration<volatile duration<_Rep, _Period> > : true_type {}; 332 333template <class _Rep, class _Period> 334struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {}; 335 336} // chrono 337 338template <class _Rep1, class _Period1, class _Rep2, class _Period2> 339struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>, 340 chrono::duration<_Rep2, _Period2> > 341{ 342 typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, 343 typename __ratio_gcd<_Period1, _Period2>::type> type; 344}; 345 346namespace chrono { 347 348// duration_cast 349 350template <class _FromDuration, class _ToDuration, 351 class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type, 352 bool = _Period::num == 1, 353 bool = _Period::den == 1> 354struct __duration_cast; 355 356template <class _FromDuration, class _ToDuration, class _Period> 357struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true> 358{ 359 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 360 _ToDuration operator()(const _FromDuration& __fd) const 361 { 362 return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count())); 363 } 364}; 365 366template <class _FromDuration, class _ToDuration, class _Period> 367struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false> 368{ 369 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 370 _ToDuration operator()(const _FromDuration& __fd) const 371 { 372 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; 373 return _ToDuration(static_cast<typename _ToDuration::rep>( 374 static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den))); 375 } 376}; 377 378template <class _FromDuration, class _ToDuration, class _Period> 379struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true> 380{ 381 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 382 _ToDuration operator()(const _FromDuration& __fd) const 383 { 384 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; 385 return _ToDuration(static_cast<typename _ToDuration::rep>( 386 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num))); 387 } 388}; 389 390template <class _FromDuration, class _ToDuration, class _Period> 391struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false> 392{ 393 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 394 _ToDuration operator()(const _FromDuration& __fd) const 395 { 396 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; 397 return _ToDuration(static_cast<typename _ToDuration::rep>( 398 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num) 399 / static_cast<_Ct>(_Period::den))); 400 } 401}; 402 403template <class _ToDuration, class _Rep, class _Period> 404inline _LIBCPP_INLINE_VISIBILITY 405_LIBCPP_CONSTEXPR 406typename enable_if 407< 408 __is_duration<_ToDuration>::value, 409 _ToDuration 410>::type 411duration_cast(const duration<_Rep, _Period>& __fd) 412{ 413 return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd); 414} 415 416template <class _Rep> 417struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; 418 419#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) 420template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v 421 = treat_as_floating_point<_Rep>::value; 422#endif 423 424template <class _Rep> 425struct _LIBCPP_TEMPLATE_VIS duration_values 426{ 427public: 428 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);} 429 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();} 430 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();} 431}; 432 433#if _LIBCPP_STD_VER > 14 434template <class _ToDuration, class _Rep, class _Period> 435inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 436typename enable_if 437< 438 __is_duration<_ToDuration>::value, 439 _ToDuration 440>::type 441floor(const duration<_Rep, _Period>& __d) 442{ 443 _ToDuration __t = duration_cast<_ToDuration>(__d); 444 if (__t > __d) 445 __t = __t - _ToDuration{1}; 446 return __t; 447} 448 449template <class _ToDuration, class _Rep, class _Period> 450inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 451typename enable_if 452< 453 __is_duration<_ToDuration>::value, 454 _ToDuration 455>::type 456ceil(const duration<_Rep, _Period>& __d) 457{ 458 _ToDuration __t = duration_cast<_ToDuration>(__d); 459 if (__t < __d) 460 __t = __t + _ToDuration{1}; 461 return __t; 462} 463 464template <class _ToDuration, class _Rep, class _Period> 465inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 466typename enable_if 467< 468 __is_duration<_ToDuration>::value, 469 _ToDuration 470>::type 471round(const duration<_Rep, _Period>& __d) 472{ 473 _ToDuration __lower = floor<_ToDuration>(__d); 474 _ToDuration __upper = __lower + _ToDuration{1}; 475 auto __lowerDiff = __d - __lower; 476 auto __upperDiff = __upper - __d; 477 if (__lowerDiff < __upperDiff) 478 return __lower; 479 if (__lowerDiff > __upperDiff) 480 return __upper; 481 return __lower.count() & 1 ? __upper : __lower; 482} 483#endif 484 485// duration 486 487template <class _Rep, class _Period> 488class _LIBCPP_TEMPLATE_VIS duration 489{ 490 static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration"); 491 static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio"); 492 static_assert(_Period::num > 0, "duration period must be positive"); 493 494 template <class _R1, class _R2> 495 struct __no_overflow 496 { 497 private: 498 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value; 499 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value; 500 static const intmax_t __n1 = _R1::num / __gcd_n1_n2; 501 static const intmax_t __d1 = _R1::den / __gcd_d1_d2; 502 static const intmax_t __n2 = _R2::num / __gcd_n1_n2; 503 static const intmax_t __d2 = _R2::den / __gcd_d1_d2; 504 static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1); 505 506 template <intmax_t _Xp, intmax_t _Yp, bool __overflow> 507 struct __mul // __overflow == false 508 { 509 static const intmax_t value = _Xp * _Yp; 510 }; 511 512 template <intmax_t _Xp, intmax_t _Yp> 513 struct __mul<_Xp, _Yp, true> 514 { 515 static const intmax_t value = 1; 516 }; 517 518 public: 519 static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1); 520 typedef ratio<__mul<__n1, __d2, !value>::value, 521 __mul<__n2, __d1, !value>::value> type; 522 }; 523 524public: 525 typedef _Rep rep; 526 typedef _Period period; 527private: 528 rep __rep_; 529public: 530 531 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 532#ifndef _LIBCPP_CXX03_LANG 533 duration() = default; 534#else 535 duration() {} 536#endif 537 538 template <class _Rep2> 539 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 540 explicit duration(const _Rep2& __r, 541 typename enable_if 542 < 543 is_convertible<_Rep2, rep>::value && 544 (treat_as_floating_point<rep>::value || 545 !treat_as_floating_point<_Rep2>::value) 546 >::type* = 0) 547 : __rep_(__r) {} 548 549 // conversions 550 template <class _Rep2, class _Period2> 551 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 552 duration(const duration<_Rep2, _Period2>& __d, 553 typename enable_if 554 < 555 __no_overflow<_Period2, period>::value && ( 556 treat_as_floating_point<rep>::value || 557 (__no_overflow<_Period2, period>::type::den == 1 && 558 !treat_as_floating_point<_Rep2>::value)) 559 >::type* = 0) 560 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {} 561 562 // observer 563 564 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;} 565 566 // arithmetic 567 568 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator+() const {return *this;} 569 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator-() const {return duration(-__rep_);} 570 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;} 571 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);} 572 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;} 573 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);} 574 575 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;} 576 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;} 577 578 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;} 579 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;} 580 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;} 581 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;} 582 583 // special values 584 585 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());} 586 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());} 587 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());} 588}; 589 590typedef duration<long long, nano> nanoseconds; 591typedef duration<long long, micro> microseconds; 592typedef duration<long long, milli> milliseconds; 593typedef duration<long long > seconds; 594typedef duration< long, ratio< 60> > minutes; 595typedef duration< long, ratio<3600> > hours; 596 597// Duration == 598 599template <class _LhsDuration, class _RhsDuration> 600struct __duration_eq 601{ 602 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 603 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const 604 { 605 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; 606 return _Ct(__lhs).count() == _Ct(__rhs).count(); 607 } 608}; 609 610template <class _LhsDuration> 611struct __duration_eq<_LhsDuration, _LhsDuration> 612{ 613 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 614 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const 615 {return __lhs.count() == __rhs.count();} 616}; 617 618template <class _Rep1, class _Period1, class _Rep2, class _Period2> 619inline _LIBCPP_INLINE_VISIBILITY 620_LIBCPP_CONSTEXPR 621bool 622operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 623{ 624 return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); 625} 626 627// Duration != 628 629template <class _Rep1, class _Period1, class _Rep2, class _Period2> 630inline _LIBCPP_INLINE_VISIBILITY 631_LIBCPP_CONSTEXPR 632bool 633operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 634{ 635 return !(__lhs == __rhs); 636} 637 638// Duration < 639 640template <class _LhsDuration, class _RhsDuration> 641struct __duration_lt 642{ 643 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 644 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const 645 { 646 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; 647 return _Ct(__lhs).count() < _Ct(__rhs).count(); 648 } 649}; 650 651template <class _LhsDuration> 652struct __duration_lt<_LhsDuration, _LhsDuration> 653{ 654 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 655 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const 656 {return __lhs.count() < __rhs.count();} 657}; 658 659template <class _Rep1, class _Period1, class _Rep2, class _Period2> 660inline _LIBCPP_INLINE_VISIBILITY 661_LIBCPP_CONSTEXPR 662bool 663operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 664{ 665 return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); 666} 667 668// Duration > 669 670template <class _Rep1, class _Period1, class _Rep2, class _Period2> 671inline _LIBCPP_INLINE_VISIBILITY 672_LIBCPP_CONSTEXPR 673bool 674operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 675{ 676 return __rhs < __lhs; 677} 678 679// Duration <= 680 681template <class _Rep1, class _Period1, class _Rep2, class _Period2> 682inline _LIBCPP_INLINE_VISIBILITY 683_LIBCPP_CONSTEXPR 684bool 685operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 686{ 687 return !(__rhs < __lhs); 688} 689 690// Duration >= 691 692template <class _Rep1, class _Period1, class _Rep2, class _Period2> 693inline _LIBCPP_INLINE_VISIBILITY 694_LIBCPP_CONSTEXPR 695bool 696operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 697{ 698 return !(__lhs < __rhs); 699} 700 701// Duration + 702 703template <class _Rep1, class _Period1, class _Rep2, class _Period2> 704inline _LIBCPP_INLINE_VISIBILITY 705_LIBCPP_CONSTEXPR 706typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 707operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 708{ 709 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 710 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count()); 711} 712 713// Duration - 714 715template <class _Rep1, class _Period1, class _Rep2, class _Period2> 716inline _LIBCPP_INLINE_VISIBILITY 717_LIBCPP_CONSTEXPR 718typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 719operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 720{ 721 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 722 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count()); 723} 724 725// Duration * 726 727template <class _Rep1, class _Period, class _Rep2> 728inline _LIBCPP_INLINE_VISIBILITY 729_LIBCPP_CONSTEXPR 730typename enable_if 731< 732 is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, 733 duration<typename common_type<_Rep1, _Rep2>::type, _Period> 734>::type 735operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 736{ 737 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 738 typedef duration<_Cr, _Period> _Cd; 739 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s)); 740} 741 742template <class _Rep1, class _Period, class _Rep2> 743inline _LIBCPP_INLINE_VISIBILITY 744_LIBCPP_CONSTEXPR 745typename enable_if 746< 747 is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, 748 duration<typename common_type<_Rep1, _Rep2>::type, _Period> 749>::type 750operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 751{ 752 return __d * __s; 753} 754 755// Duration / 756 757template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value> 758struct __duration_divide_result 759{ 760}; 761 762template <class _Duration, class _Rep2, 763 bool = is_convertible<_Rep2, 764 typename common_type<typename _Duration::rep, _Rep2>::type>::value> 765struct __duration_divide_imp 766{ 767}; 768 769template <class _Rep1, class _Period, class _Rep2> 770struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true> 771{ 772 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type; 773}; 774 775template <class _Rep1, class _Period, class _Rep2> 776struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false> 777 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2> 778{ 779}; 780 781template <class _Rep1, class _Period, class _Rep2> 782inline _LIBCPP_INLINE_VISIBILITY 783_LIBCPP_CONSTEXPR 784typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 785operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 786{ 787 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 788 typedef duration<_Cr, _Period> _Cd; 789 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s)); 790} 791 792template <class _Rep1, class _Period1, class _Rep2, class _Period2> 793inline _LIBCPP_INLINE_VISIBILITY 794_LIBCPP_CONSTEXPR 795typename common_type<_Rep1, _Rep2>::type 796operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 797{ 798 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct; 799 return _Ct(__lhs).count() / _Ct(__rhs).count(); 800} 801 802// Duration % 803 804template <class _Rep1, class _Period, class _Rep2> 805inline _LIBCPP_INLINE_VISIBILITY 806_LIBCPP_CONSTEXPR 807typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 808operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 809{ 810 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 811 typedef duration<_Cr, _Period> _Cd; 812 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s)); 813} 814 815template <class _Rep1, class _Period1, class _Rep2, class _Period2> 816inline _LIBCPP_INLINE_VISIBILITY 817_LIBCPP_CONSTEXPR 818typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 819operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 820{ 821 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 822 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 823 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count())); 824} 825 826////////////////////////////////////////////////////////// 827///////////////////// time_point ///////////////////////// 828////////////////////////////////////////////////////////// 829 830template <class _Clock, class _Duration = typename _Clock::duration> 831class _LIBCPP_TEMPLATE_VIS time_point 832{ 833 static_assert(__is_duration<_Duration>::value, 834 "Second template parameter of time_point must be a std::chrono::duration"); 835public: 836 typedef _Clock clock; 837 typedef _Duration duration; 838 typedef typename duration::rep rep; 839 typedef typename duration::period period; 840private: 841 duration __d_; 842 843public: 844 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {} 845 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {} 846 847 // conversions 848 template <class _Duration2> 849 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 850 time_point(const time_point<clock, _Duration2>& t, 851 typename enable_if 852 < 853 is_convertible<_Duration2, duration>::value 854 >::type* = 0) 855 : __d_(t.time_since_epoch()) {} 856 857 // observer 858 859 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;} 860 861 // arithmetic 862 863 _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;} 864 _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;} 865 866 // special values 867 868 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());} 869 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());} 870}; 871 872} // chrono 873 874template <class _Clock, class _Duration1, class _Duration2> 875struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>, 876 chrono::time_point<_Clock, _Duration2> > 877{ 878 typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type; 879}; 880 881namespace chrono { 882 883template <class _ToDuration, class _Clock, class _Duration> 884inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 885time_point<_Clock, _ToDuration> 886time_point_cast(const time_point<_Clock, _Duration>& __t) 887{ 888 return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); 889} 890 891#if _LIBCPP_STD_VER > 14 892template <class _ToDuration, class _Clock, class _Duration> 893inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 894typename enable_if 895< 896 __is_duration<_ToDuration>::value, 897 time_point<_Clock, _ToDuration> 898>::type 899floor(const time_point<_Clock, _Duration>& __t) 900{ 901 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())}; 902} 903 904template <class _ToDuration, class _Clock, class _Duration> 905inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 906typename enable_if 907< 908 __is_duration<_ToDuration>::value, 909 time_point<_Clock, _ToDuration> 910>::type 911ceil(const time_point<_Clock, _Duration>& __t) 912{ 913 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())}; 914} 915 916template <class _ToDuration, class _Clock, class _Duration> 917inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 918typename enable_if 919< 920 __is_duration<_ToDuration>::value, 921 time_point<_Clock, _ToDuration> 922>::type 923round(const time_point<_Clock, _Duration>& __t) 924{ 925 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())}; 926} 927 928template <class _Rep, class _Period> 929inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 930typename enable_if 931< 932 numeric_limits<_Rep>::is_signed, 933 duration<_Rep, _Period> 934>::type 935abs(duration<_Rep, _Period> __d) 936{ 937 return __d >= __d.zero() ? __d : -__d; 938} 939#endif 940 941// time_point == 942 943template <class _Clock, class _Duration1, class _Duration2> 944inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 945bool 946operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 947{ 948 return __lhs.time_since_epoch() == __rhs.time_since_epoch(); 949} 950 951// time_point != 952 953template <class _Clock, class _Duration1, class _Duration2> 954inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 955bool 956operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 957{ 958 return !(__lhs == __rhs); 959} 960 961// time_point < 962 963template <class _Clock, class _Duration1, class _Duration2> 964inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 965bool 966operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 967{ 968 return __lhs.time_since_epoch() < __rhs.time_since_epoch(); 969} 970 971// time_point > 972 973template <class _Clock, class _Duration1, class _Duration2> 974inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 975bool 976operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 977{ 978 return __rhs < __lhs; 979} 980 981// time_point <= 982 983template <class _Clock, class _Duration1, class _Duration2> 984inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 985bool 986operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 987{ 988 return !(__rhs < __lhs); 989} 990 991// time_point >= 992 993template <class _Clock, class _Duration1, class _Duration2> 994inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 995bool 996operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 997{ 998 return !(__lhs < __rhs); 999} 1000 1001// time_point operator+(time_point x, duration y); 1002 1003template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1004inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1005time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1006operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1007{ 1008 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr; 1009 return _Tr (__lhs.time_since_epoch() + __rhs); 1010} 1011 1012// time_point operator+(duration x, time_point y); 1013 1014template <class _Rep1, class _Period1, class _Clock, class _Duration2> 1015inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1016time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> 1017operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1018{ 1019 return __rhs + __lhs; 1020} 1021 1022// time_point operator-(time_point x, duration y); 1023 1024template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1025inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1026time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1027operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1028{ 1029 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret; 1030 return _Ret(__lhs.time_since_epoch() -__rhs); 1031} 1032 1033// duration operator-(time_point x, time_point y); 1034 1035template <class _Clock, class _Duration1, class _Duration2> 1036inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1037typename common_type<_Duration1, _Duration2>::type 1038operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1039{ 1040 return __lhs.time_since_epoch() - __rhs.time_since_epoch(); 1041} 1042 1043////////////////////////////////////////////////////////// 1044/////////////////////// clocks /////////////////////////// 1045////////////////////////////////////////////////////////// 1046 1047class _LIBCPP_TYPE_VIS system_clock 1048{ 1049public: 1050 typedef microseconds duration; 1051 typedef duration::rep rep; 1052 typedef duration::period period; 1053 typedef chrono::time_point<system_clock> time_point; 1054 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false; 1055 1056 static time_point now() _NOEXCEPT; 1057 static time_t to_time_t (const time_point& __t) _NOEXCEPT; 1058 static time_point from_time_t(time_t __t) _NOEXCEPT; 1059}; 1060 1061#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK 1062class _LIBCPP_TYPE_VIS steady_clock 1063{ 1064public: 1065 typedef nanoseconds duration; 1066 typedef duration::rep rep; 1067 typedef duration::period period; 1068 typedef chrono::time_point<steady_clock, duration> time_point; 1069 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true; 1070 1071 static time_point now() _NOEXCEPT; 1072}; 1073 1074typedef steady_clock high_resolution_clock; 1075#else 1076typedef system_clock high_resolution_clock; 1077#endif 1078 1079} // chrono 1080 1081#if _LIBCPP_STD_VER > 11 1082// Suffixes for duration literals [time.duration.literals] 1083inline namespace literals 1084{ 1085 inline namespace chrono_literals 1086 { 1087 1088 constexpr chrono::hours operator"" h(unsigned long long __h) 1089 { 1090 return chrono::hours(static_cast<chrono::hours::rep>(__h)); 1091 } 1092 1093 constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long double __h) 1094 { 1095 return chrono::duration<long double, ratio<3600,1>>(__h); 1096 } 1097 1098 1099 constexpr chrono::minutes operator"" min(unsigned long long __m) 1100 { 1101 return chrono::minutes(static_cast<chrono::minutes::rep>(__m)); 1102 } 1103 1104 constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long double __m) 1105 { 1106 return chrono::duration<long double, ratio<60,1>> (__m); 1107 } 1108 1109 1110 constexpr chrono::seconds operator"" s(unsigned long long __s) 1111 { 1112 return chrono::seconds(static_cast<chrono::seconds::rep>(__s)); 1113 } 1114 1115 constexpr chrono::duration<long double> operator"" s(long double __s) 1116 { 1117 return chrono::duration<long double> (__s); 1118 } 1119 1120 1121 constexpr chrono::milliseconds operator"" ms(unsigned long long __ms) 1122 { 1123 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms)); 1124 } 1125 1126 constexpr chrono::duration<long double, milli> operator"" ms(long double __ms) 1127 { 1128 return chrono::duration<long double, milli>(__ms); 1129 } 1130 1131 1132 constexpr chrono::microseconds operator"" us(unsigned long long __us) 1133 { 1134 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us)); 1135 } 1136 1137 constexpr chrono::duration<long double, micro> operator"" us(long double __us) 1138 { 1139 return chrono::duration<long double, micro> (__us); 1140 } 1141 1142 1143 constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns) 1144 { 1145 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns)); 1146 } 1147 1148 constexpr chrono::duration<long double, nano> operator"" ns(long double __ns) 1149 { 1150 return chrono::duration<long double, nano> (__ns); 1151 } 1152 1153}} 1154 1155namespace chrono { // hoist the literals into namespace std::chrono 1156 using namespace literals::chrono_literals; 1157} 1158 1159#endif 1160 1161_LIBCPP_END_NAMESPACE_STD 1162 1163#endif // _LIBCPP_CHRONO 1164