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> inline 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> 423 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool treat_as_floating_point_v 424 = treat_as_floating_point<_Rep>::value; 425 #endif 426 427 template <class _Rep> 428 struct _LIBCPP_TEMPLATE_VIS duration_values 429 { 430 public: 431 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);} 432 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();} 433 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();} 434 }; 435 436 #if _LIBCPP_STD_VER > 14 437 template <class _ToDuration, class _Rep, class _Period> 438 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 439 typename enable_if 440 < 441 __is_duration<_ToDuration>::value, 442 _ToDuration 443 >::type 444 floor(const duration<_Rep, _Period>& __d) 445 { 446 _ToDuration __t = duration_cast<_ToDuration>(__d); 447 if (__t > __d) 448 __t = __t - _ToDuration{1}; 449 return __t; 450 } 451 452 template <class _ToDuration, class _Rep, class _Period> 453 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 454 typename enable_if 455 < 456 __is_duration<_ToDuration>::value, 457 _ToDuration 458 >::type 459 ceil(const duration<_Rep, _Period>& __d) 460 { 461 _ToDuration __t = duration_cast<_ToDuration>(__d); 462 if (__t < __d) 463 __t = __t + _ToDuration{1}; 464 return __t; 465 } 466 467 template <class _ToDuration, class _Rep, class _Period> 468 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 469 typename enable_if 470 < 471 __is_duration<_ToDuration>::value, 472 _ToDuration 473 >::type 474 round(const duration<_Rep, _Period>& __d) 475 { 476 _ToDuration __lower = floor<_ToDuration>(__d); 477 _ToDuration __upper = __lower + _ToDuration{1}; 478 auto __lowerDiff = __d - __lower; 479 auto __upperDiff = __upper - __d; 480 if (__lowerDiff < __upperDiff) 481 return __lower; 482 if (__lowerDiff > __upperDiff) 483 return __upper; 484 return __lower.count() & 1 ? __upper : __lower; 485 } 486 #endif 487 488 // duration 489 490 template <class _Rep, class _Period> 491 class _LIBCPP_TEMPLATE_VIS duration 492 { 493 static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration"); 494 static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio"); 495 static_assert(_Period::num > 0, "duration period must be positive"); 496 497 template <class _R1, class _R2> 498 struct __no_overflow 499 { 500 private: 501 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value; 502 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value; 503 static const intmax_t __n1 = _R1::num / __gcd_n1_n2; 504 static const intmax_t __d1 = _R1::den / __gcd_d1_d2; 505 static const intmax_t __n2 = _R2::num / __gcd_n1_n2; 506 static const intmax_t __d2 = _R2::den / __gcd_d1_d2; 507 static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1); 508 509 template <intmax_t _Xp, intmax_t _Yp, bool __overflow> 510 struct __mul // __overflow == false 511 { 512 static const intmax_t value = _Xp * _Yp; 513 }; 514 515 template <intmax_t _Xp, intmax_t _Yp> 516 struct __mul<_Xp, _Yp, true> 517 { 518 static const intmax_t value = 1; 519 }; 520 521 public: 522 static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1); 523 typedef ratio<__mul<__n1, __d2, !value>::value, 524 __mul<__n2, __d1, !value>::value> type; 525 }; 526 527 public: 528 typedef _Rep rep; 529 typedef typename _Period::type period; 530 private: 531 rep __rep_; 532 public: 533 534 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 535 #ifndef _LIBCPP_CXX03_LANG 536 duration() = default; 537 #else 538 duration() {} 539 #endif 540 541 template <class _Rep2> 542 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 543 explicit duration(const _Rep2& __r, 544 typename enable_if 545 < 546 is_convertible<_Rep2, rep>::value && 547 (treat_as_floating_point<rep>::value || 548 !treat_as_floating_point<_Rep2>::value) 549 >::type* = 0) 550 : __rep_(__r) {} 551 552 // conversions 553 template <class _Rep2, class _Period2> 554 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 555 duration(const duration<_Rep2, _Period2>& __d, 556 typename enable_if 557 < 558 __no_overflow<_Period2, period>::value && ( 559 treat_as_floating_point<rep>::value || 560 (__no_overflow<_Period2, period>::type::den == 1 && 561 !treat_as_floating_point<_Rep2>::value)) 562 >::type* = 0) 563 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {} 564 565 // observer 566 567 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;} 568 569 // arithmetic 570 571 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);} 572 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);} 573 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;} 574 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);} 575 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;} 576 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);} 577 578 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;} 579 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;} 580 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 rep& rhs) {__rep_ %= rhs; return *this;} 584 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;} 585 586 // special values 587 588 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());} 589 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());} 590 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());} 591 }; 592 593 typedef duration<long long, nano> nanoseconds; 594 typedef duration<long long, micro> microseconds; 595 typedef duration<long long, milli> milliseconds; 596 typedef duration<long long > seconds; 597 typedef duration< long, ratio< 60> > minutes; 598 typedef duration< long, ratio<3600> > hours; 599 600 // Duration == 601 602 template <class _LhsDuration, class _RhsDuration> 603 struct __duration_eq 604 { 605 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 606 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const 607 { 608 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; 609 return _Ct(__lhs).count() == _Ct(__rhs).count(); 610 } 611 }; 612 613 template <class _LhsDuration> 614 struct __duration_eq<_LhsDuration, _LhsDuration> 615 { 616 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 617 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const 618 {return __lhs.count() == __rhs.count();} 619 }; 620 621 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 622 inline _LIBCPP_INLINE_VISIBILITY 623 _LIBCPP_CONSTEXPR 624 bool 625 operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 626 { 627 return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); 628 } 629 630 // Duration != 631 632 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 633 inline _LIBCPP_INLINE_VISIBILITY 634 _LIBCPP_CONSTEXPR 635 bool 636 operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 637 { 638 return !(__lhs == __rhs); 639 } 640 641 // Duration < 642 643 template <class _LhsDuration, class _RhsDuration> 644 struct __duration_lt 645 { 646 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 647 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const 648 { 649 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; 650 return _Ct(__lhs).count() < _Ct(__rhs).count(); 651 } 652 }; 653 654 template <class _LhsDuration> 655 struct __duration_lt<_LhsDuration, _LhsDuration> 656 { 657 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 658 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const 659 {return __lhs.count() < __rhs.count();} 660 }; 661 662 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 663 inline _LIBCPP_INLINE_VISIBILITY 664 _LIBCPP_CONSTEXPR 665 bool 666 operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 667 { 668 return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); 669 } 670 671 // Duration > 672 673 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 674 inline _LIBCPP_INLINE_VISIBILITY 675 _LIBCPP_CONSTEXPR 676 bool 677 operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 678 { 679 return __rhs < __lhs; 680 } 681 682 // Duration <= 683 684 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 685 inline _LIBCPP_INLINE_VISIBILITY 686 _LIBCPP_CONSTEXPR 687 bool 688 operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 689 { 690 return !(__rhs < __lhs); 691 } 692 693 // Duration >= 694 695 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 696 inline _LIBCPP_INLINE_VISIBILITY 697 _LIBCPP_CONSTEXPR 698 bool 699 operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 700 { 701 return !(__lhs < __rhs); 702 } 703 704 // Duration + 705 706 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 707 inline _LIBCPP_INLINE_VISIBILITY 708 _LIBCPP_CONSTEXPR 709 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 710 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 711 { 712 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 713 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count()); 714 } 715 716 // Duration - 717 718 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 719 inline _LIBCPP_INLINE_VISIBILITY 720 _LIBCPP_CONSTEXPR 721 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 722 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 723 { 724 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 725 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count()); 726 } 727 728 // Duration * 729 730 template <class _Rep1, class _Period, class _Rep2> 731 inline _LIBCPP_INLINE_VISIBILITY 732 _LIBCPP_CONSTEXPR 733 typename enable_if 734 < 735 is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, 736 duration<typename common_type<_Rep1, _Rep2>::type, _Period> 737 >::type 738 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 739 { 740 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 741 typedef duration<_Cr, _Period> _Cd; 742 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s)); 743 } 744 745 template <class _Rep1, class _Period, class _Rep2> 746 inline _LIBCPP_INLINE_VISIBILITY 747 _LIBCPP_CONSTEXPR 748 typename enable_if 749 < 750 is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, 751 duration<typename common_type<_Rep1, _Rep2>::type, _Period> 752 >::type 753 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 754 { 755 return __d * __s; 756 } 757 758 // Duration / 759 760 template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value> 761 struct __duration_divide_result 762 { 763 }; 764 765 template <class _Duration, class _Rep2, 766 bool = is_convertible<_Rep2, 767 typename common_type<typename _Duration::rep, _Rep2>::type>::value> 768 struct __duration_divide_imp 769 { 770 }; 771 772 template <class _Rep1, class _Period, class _Rep2> 773 struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true> 774 { 775 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type; 776 }; 777 778 template <class _Rep1, class _Period, class _Rep2> 779 struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false> 780 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2> 781 { 782 }; 783 784 template <class _Rep1, class _Period, class _Rep2> 785 inline _LIBCPP_INLINE_VISIBILITY 786 _LIBCPP_CONSTEXPR 787 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 788 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 789 { 790 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 791 typedef duration<_Cr, _Period> _Cd; 792 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s)); 793 } 794 795 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 796 inline _LIBCPP_INLINE_VISIBILITY 797 _LIBCPP_CONSTEXPR 798 typename common_type<_Rep1, _Rep2>::type 799 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 800 { 801 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct; 802 return _Ct(__lhs).count() / _Ct(__rhs).count(); 803 } 804 805 // Duration % 806 807 template <class _Rep1, class _Period, class _Rep2> 808 inline _LIBCPP_INLINE_VISIBILITY 809 _LIBCPP_CONSTEXPR 810 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 811 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 812 { 813 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 814 typedef duration<_Cr, _Period> _Cd; 815 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s)); 816 } 817 818 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 819 inline _LIBCPP_INLINE_VISIBILITY 820 _LIBCPP_CONSTEXPR 821 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 822 operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 823 { 824 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 825 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 826 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count())); 827 } 828 829 ////////////////////////////////////////////////////////// 830 ///////////////////// time_point ///////////////////////// 831 ////////////////////////////////////////////////////////// 832 833 template <class _Clock, class _Duration = typename _Clock::duration> 834 class _LIBCPP_TEMPLATE_VIS time_point 835 { 836 static_assert(__is_duration<_Duration>::value, 837 "Second template parameter of time_point must be a std::chrono::duration"); 838 public: 839 typedef _Clock clock; 840 typedef _Duration duration; 841 typedef typename duration::rep rep; 842 typedef typename duration::period period; 843 private: 844 duration __d_; 845 846 public: 847 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {} 848 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {} 849 850 // conversions 851 template <class _Duration2> 852 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 853 time_point(const time_point<clock, _Duration2>& t, 854 typename enable_if 855 < 856 is_convertible<_Duration2, duration>::value 857 >::type* = 0) 858 : __d_(t.time_since_epoch()) {} 859 860 // observer 861 862 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;} 863 864 // arithmetic 865 866 _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;} 867 _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;} 868 869 // special values 870 871 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());} 872 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());} 873 }; 874 875 } // chrono 876 877 template <class _Clock, class _Duration1, class _Duration2> 878 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>, 879 chrono::time_point<_Clock, _Duration2> > 880 { 881 typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type; 882 }; 883 884 namespace chrono { 885 886 template <class _ToDuration, class _Clock, class _Duration> 887 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 888 time_point<_Clock, _ToDuration> 889 time_point_cast(const time_point<_Clock, _Duration>& __t) 890 { 891 return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); 892 } 893 894 #if _LIBCPP_STD_VER > 14 895 template <class _ToDuration, class _Clock, class _Duration> 896 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 897 typename enable_if 898 < 899 __is_duration<_ToDuration>::value, 900 time_point<_Clock, _ToDuration> 901 >::type 902 floor(const time_point<_Clock, _Duration>& __t) 903 { 904 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())}; 905 } 906 907 template <class _ToDuration, class _Clock, class _Duration> 908 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 909 typename enable_if 910 < 911 __is_duration<_ToDuration>::value, 912 time_point<_Clock, _ToDuration> 913 >::type 914 ceil(const time_point<_Clock, _Duration>& __t) 915 { 916 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())}; 917 } 918 919 template <class _ToDuration, class _Clock, class _Duration> 920 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 921 typename enable_if 922 < 923 __is_duration<_ToDuration>::value, 924 time_point<_Clock, _ToDuration> 925 >::type 926 round(const time_point<_Clock, _Duration>& __t) 927 { 928 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())}; 929 } 930 931 template <class _Rep, class _Period> 932 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 933 typename enable_if 934 < 935 numeric_limits<_Rep>::is_signed, 936 duration<_Rep, _Period> 937 >::type 938 abs(duration<_Rep, _Period> __d) 939 { 940 return __d >= __d.zero() ? __d : -__d; 941 } 942 #endif 943 944 // time_point == 945 946 template <class _Clock, class _Duration1, class _Duration2> 947 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 948 bool 949 operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 950 { 951 return __lhs.time_since_epoch() == __rhs.time_since_epoch(); 952 } 953 954 // time_point != 955 956 template <class _Clock, class _Duration1, class _Duration2> 957 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 958 bool 959 operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 960 { 961 return !(__lhs == __rhs); 962 } 963 964 // time_point < 965 966 template <class _Clock, class _Duration1, class _Duration2> 967 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 968 bool 969 operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 970 { 971 return __lhs.time_since_epoch() < __rhs.time_since_epoch(); 972 } 973 974 // time_point > 975 976 template <class _Clock, class _Duration1, class _Duration2> 977 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 978 bool 979 operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 980 { 981 return __rhs < __lhs; 982 } 983 984 // time_point <= 985 986 template <class _Clock, class _Duration1, class _Duration2> 987 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 988 bool 989 operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 990 { 991 return !(__rhs < __lhs); 992 } 993 994 // time_point >= 995 996 template <class _Clock, class _Duration1, class _Duration2> 997 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 998 bool 999 operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1000 { 1001 return !(__lhs < __rhs); 1002 } 1003 1004 // time_point operator+(time_point x, duration y); 1005 1006 template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1007 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1008 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1009 operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1010 { 1011 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr; 1012 return _Tr (__lhs.time_since_epoch() + __rhs); 1013 } 1014 1015 // time_point operator+(duration x, time_point y); 1016 1017 template <class _Rep1, class _Period1, class _Clock, class _Duration2> 1018 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1019 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> 1020 operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1021 { 1022 return __rhs + __lhs; 1023 } 1024 1025 // time_point operator-(time_point x, duration y); 1026 1027 template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1028 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1029 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1030 operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1031 { 1032 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret; 1033 return _Ret(__lhs.time_since_epoch() -__rhs); 1034 } 1035 1036 // duration operator-(time_point x, time_point y); 1037 1038 template <class _Clock, class _Duration1, class _Duration2> 1039 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1040 typename common_type<_Duration1, _Duration2>::type 1041 operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1042 { 1043 return __lhs.time_since_epoch() - __rhs.time_since_epoch(); 1044 } 1045 1046 ////////////////////////////////////////////////////////// 1047 /////////////////////// clocks /////////////////////////// 1048 ////////////////////////////////////////////////////////// 1049 1050 class _LIBCPP_TYPE_VIS system_clock 1051 { 1052 public: 1053 typedef microseconds duration; 1054 typedef duration::rep rep; 1055 typedef duration::period period; 1056 typedef chrono::time_point<system_clock> time_point; 1057 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false; 1058 1059 static time_point now() _NOEXCEPT; 1060 static time_t to_time_t (const time_point& __t) _NOEXCEPT; 1061 static time_point from_time_t(time_t __t) _NOEXCEPT; 1062 }; 1063 1064 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK 1065 class _LIBCPP_TYPE_VIS steady_clock 1066 { 1067 public: 1068 typedef nanoseconds duration; 1069 typedef duration::rep rep; 1070 typedef duration::period period; 1071 typedef chrono::time_point<steady_clock, duration> time_point; 1072 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true; 1073 1074 static time_point now() _NOEXCEPT; 1075 }; 1076 1077 typedef steady_clock high_resolution_clock; 1078 #else 1079 typedef system_clock high_resolution_clock; 1080 #endif 1081 1082 } // chrono 1083 1084 #if _LIBCPP_STD_VER > 11 1085 // Suffixes for duration literals [time.duration.literals] 1086 inline namespace literals 1087 { 1088 inline namespace chrono_literals 1089 { 1090 1091 constexpr chrono::hours operator""h(unsigned long long __h) 1092 { 1093 return chrono::hours(static_cast<chrono::hours::rep>(__h)); 1094 } 1095 1096 constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h) 1097 { 1098 return chrono::duration<long double, ratio<3600,1>>(__h); 1099 } 1100 1101 1102 constexpr chrono::minutes operator""min(unsigned long long __m) 1103 { 1104 return chrono::minutes(static_cast<chrono::minutes::rep>(__m)); 1105 } 1106 1107 constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m) 1108 { 1109 return chrono::duration<long double, ratio<60,1>> (__m); 1110 } 1111 1112 1113 constexpr chrono::seconds operator""s(unsigned long long __s) 1114 { 1115 return chrono::seconds(static_cast<chrono::seconds::rep>(__s)); 1116 } 1117 1118 constexpr chrono::duration<long double> operator""s(long double __s) 1119 { 1120 return chrono::duration<long double> (__s); 1121 } 1122 1123 1124 constexpr chrono::milliseconds operator""ms(unsigned long long __ms) 1125 { 1126 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms)); 1127 } 1128 1129 constexpr chrono::duration<long double, milli> operator""ms(long double __ms) 1130 { 1131 return chrono::duration<long double, milli>(__ms); 1132 } 1133 1134 1135 constexpr chrono::microseconds operator""us(unsigned long long __us) 1136 { 1137 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us)); 1138 } 1139 1140 constexpr chrono::duration<long double, micro> operator""us(long double __us) 1141 { 1142 return chrono::duration<long double, micro> (__us); 1143 } 1144 1145 1146 constexpr chrono::nanoseconds operator""ns(unsigned long long __ns) 1147 { 1148 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns)); 1149 } 1150 1151 constexpr chrono::duration<long double, nano> operator""ns(long double __ns) 1152 { 1153 return chrono::duration<long double, nano> (__ns); 1154 } 1155 1156 }} 1157 1158 namespace chrono { // hoist the literals into namespace std::chrono 1159 using namespace literals::chrono_literals; 1160 } 1161 1162 #endif 1163 1164 _LIBCPP_END_NAMESPACE_STD 1165 1166 _LIBCPP_POP_MACROS 1167 1168 #endif // _LIBCPP_CHRONO 1169
