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