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 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 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 #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 316 namespace chrono 317 { 318 319 template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration; 320 321 template <class _Tp> 322 struct __is_duration : false_type {}; 323 324 template <class _Rep, class _Period> 325 struct __is_duration<duration<_Rep, _Period> > : true_type {}; 326 327 template <class _Rep, class _Period> 328 struct __is_duration<const duration<_Rep, _Period> > : true_type {}; 329 330 template <class _Rep, class _Period> 331 struct __is_duration<volatile duration<_Rep, _Period> > : true_type {}; 332 333 template <class _Rep, class _Period> 334 struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {}; 335 336 } // chrono 337 338 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 339 struct _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 346 namespace chrono { 347 348 // duration_cast 349 350 template <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> 354 struct __duration_cast; 355 356 template <class _FromDuration, class _ToDuration, class _Period> 357 struct __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 366 template <class _FromDuration, class _ToDuration, class _Period> 367 struct __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 378 template <class _FromDuration, class _ToDuration, class _Period> 379 struct __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 390 template <class _FromDuration, class _ToDuration, class _Period> 391 struct __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 403 template <class _ToDuration, class _Rep, class _Period> 404 inline _LIBCPP_INLINE_VISIBILITY 405 _LIBCPP_CONSTEXPR 406 typename enable_if 407 < 408 __is_duration<_ToDuration>::value, 409 _ToDuration 410 >::type 411 duration_cast(const duration<_Rep, _Period>& __fd) 412 { 413 return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd); 414 } 415 416 template <class _Rep> 417 struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; 418 419 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) 420 template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v 421 = treat_as_floating_point<_Rep>::value; 422 #endif 423 424 template <class _Rep> 425 struct _LIBCPP_TEMPLATE_VIS duration_values 426 { 427 public: 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 434 template <class _ToDuration, class _Rep, class _Period> 435 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 436 typename enable_if 437 < 438 __is_duration<_ToDuration>::value, 439 _ToDuration 440 >::type 441 floor(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 449 template <class _ToDuration, class _Rep, class _Period> 450 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 451 typename enable_if 452 < 453 __is_duration<_ToDuration>::value, 454 _ToDuration 455 >::type 456 ceil(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 464 template <class _ToDuration, class _Rep, class _Period> 465 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 466 typename enable_if 467 < 468 __is_duration<_ToDuration>::value, 469 _ToDuration 470 >::type 471 round(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 487 template <class _Rep, class _Period> 488 class _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 524 public: 525 typedef _Rep rep; 526 typedef _Period period; 527 private: 528 rep __rep_; 529 public: 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 590 typedef duration<long long, nano> nanoseconds; 591 typedef duration<long long, micro> microseconds; 592 typedef duration<long long, milli> milliseconds; 593 typedef duration<long long > seconds; 594 typedef duration< long, ratio< 60> > minutes; 595 typedef duration< long, ratio<3600> > hours; 596 597 // Duration == 598 599 template <class _LhsDuration, class _RhsDuration> 600 struct __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 610 template <class _LhsDuration> 611 struct __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 618 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 619 inline _LIBCPP_INLINE_VISIBILITY 620 _LIBCPP_CONSTEXPR 621 bool 622 operator==(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 629 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 630 inline _LIBCPP_INLINE_VISIBILITY 631 _LIBCPP_CONSTEXPR 632 bool 633 operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 634 { 635 return !(__lhs == __rhs); 636 } 637 638 // Duration < 639 640 template <class _LhsDuration, class _RhsDuration> 641 struct __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 651 template <class _LhsDuration> 652 struct __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 659 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 660 inline _LIBCPP_INLINE_VISIBILITY 661 _LIBCPP_CONSTEXPR 662 bool 663 operator< (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 670 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 671 inline _LIBCPP_INLINE_VISIBILITY 672 _LIBCPP_CONSTEXPR 673 bool 674 operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 675 { 676 return __rhs < __lhs; 677 } 678 679 // Duration <= 680 681 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 682 inline _LIBCPP_INLINE_VISIBILITY 683 _LIBCPP_CONSTEXPR 684 bool 685 operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 686 { 687 return !(__rhs < __lhs); 688 } 689 690 // Duration >= 691 692 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 693 inline _LIBCPP_INLINE_VISIBILITY 694 _LIBCPP_CONSTEXPR 695 bool 696 operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 697 { 698 return !(__lhs < __rhs); 699 } 700 701 // Duration + 702 703 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 704 inline _LIBCPP_INLINE_VISIBILITY 705 _LIBCPP_CONSTEXPR 706 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 707 operator+(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 715 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 716 inline _LIBCPP_INLINE_VISIBILITY 717 _LIBCPP_CONSTEXPR 718 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 719 operator-(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 727 template <class _Rep1, class _Period, class _Rep2> 728 inline _LIBCPP_INLINE_VISIBILITY 729 _LIBCPP_CONSTEXPR 730 typename 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 735 operator*(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 742 template <class _Rep1, class _Period, class _Rep2> 743 inline _LIBCPP_INLINE_VISIBILITY 744 _LIBCPP_CONSTEXPR 745 typename 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 750 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 751 { 752 return __d * __s; 753 } 754 755 // Duration / 756 757 template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value> 758 struct __duration_divide_result 759 { 760 }; 761 762 template <class _Duration, class _Rep2, 763 bool = is_convertible<_Rep2, 764 typename common_type<typename _Duration::rep, _Rep2>::type>::value> 765 struct __duration_divide_imp 766 { 767 }; 768 769 template <class _Rep1, class _Period, class _Rep2> 770 struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true> 771 { 772 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type; 773 }; 774 775 template <class _Rep1, class _Period, class _Rep2> 776 struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false> 777 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2> 778 { 779 }; 780 781 template <class _Rep1, class _Period, class _Rep2> 782 inline _LIBCPP_INLINE_VISIBILITY 783 _LIBCPP_CONSTEXPR 784 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 785 operator/(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 792 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 793 inline _LIBCPP_INLINE_VISIBILITY 794 _LIBCPP_CONSTEXPR 795 typename common_type<_Rep1, _Rep2>::type 796 operator/(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 804 template <class _Rep1, class _Period, class _Rep2> 805 inline _LIBCPP_INLINE_VISIBILITY 806 _LIBCPP_CONSTEXPR 807 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 808 operator%(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 815 template <class _Rep1, class _Period1, class _Rep2, class _Period2> 816 inline _LIBCPP_INLINE_VISIBILITY 817 _LIBCPP_CONSTEXPR 818 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 819 operator%(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 830 template <class _Clock, class _Duration = typename _Clock::duration> 831 class _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"); 835 public: 836 typedef _Clock clock; 837 typedef _Duration duration; 838 typedef typename duration::rep rep; 839 typedef typename duration::period period; 840 private: 841 duration __d_; 842 843 public: 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 874 template <class _Clock, class _Duration1, class _Duration2> 875 struct _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 881 namespace chrono { 882 883 template <class _ToDuration, class _Clock, class _Duration> 884 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 885 time_point<_Clock, _ToDuration> 886 time_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 892 template <class _ToDuration, class _Clock, class _Duration> 893 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 894 typename enable_if 895 < 896 __is_duration<_ToDuration>::value, 897 time_point<_Clock, _ToDuration> 898 >::type 899 floor(const time_point<_Clock, _Duration>& __t) 900 { 901 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())}; 902 } 903 904 template <class _ToDuration, class _Clock, class _Duration> 905 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 906 typename enable_if 907 < 908 __is_duration<_ToDuration>::value, 909 time_point<_Clock, _ToDuration> 910 >::type 911 ceil(const time_point<_Clock, _Duration>& __t) 912 { 913 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())}; 914 } 915 916 template <class _ToDuration, class _Clock, class _Duration> 917 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 918 typename enable_if 919 < 920 __is_duration<_ToDuration>::value, 921 time_point<_Clock, _ToDuration> 922 >::type 923 round(const time_point<_Clock, _Duration>& __t) 924 { 925 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())}; 926 } 927 928 template <class _Rep, class _Period> 929 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 930 typename enable_if 931 < 932 numeric_limits<_Rep>::is_signed, 933 duration<_Rep, _Period> 934 >::type 935 abs(duration<_Rep, _Period> __d) 936 { 937 return __d >= __d.zero() ? __d : -__d; 938 } 939 #endif 940 941 // time_point == 942 943 template <class _Clock, class _Duration1, class _Duration2> 944 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 945 bool 946 operator==(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 953 template <class _Clock, class _Duration1, class _Duration2> 954 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 955 bool 956 operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 957 { 958 return !(__lhs == __rhs); 959 } 960 961 // time_point < 962 963 template <class _Clock, class _Duration1, class _Duration2> 964 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 965 bool 966 operator<(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 973 template <class _Clock, class _Duration1, class _Duration2> 974 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 975 bool 976 operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 977 { 978 return __rhs < __lhs; 979 } 980 981 // time_point <= 982 983 template <class _Clock, class _Duration1, class _Duration2> 984 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 985 bool 986 operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 987 { 988 return !(__rhs < __lhs); 989 } 990 991 // time_point >= 992 993 template <class _Clock, class _Duration1, class _Duration2> 994 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 995 bool 996 operator>=(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 1003 template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1004 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1005 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1006 operator+(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 1014 template <class _Rep1, class _Period1, class _Clock, class _Duration2> 1015 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1016 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> 1017 operator+(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 1024 template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1025 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1026 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1027 operator-(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 1035 template <class _Clock, class _Duration1, class _Duration2> 1036 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1037 typename common_type<_Duration1, _Duration2>::type 1038 operator-(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 1047 class _LIBCPP_TYPE_VIS system_clock 1048 { 1049 public: 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 1062 class _LIBCPP_TYPE_VIS steady_clock 1063 { 1064 public: 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 1074 typedef steady_clock high_resolution_clock; 1075 #else 1076 typedef 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] 1083 inline 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 1155 namespace 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
