1// -*- C++ -*- 2//===---------------------------- chrono ----------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_CHRONO 12#define _LIBCPP_CHRONO 13 14/* 15 chrono synopsis 16 17namespace std 18{ 19namespace chrono 20{ 21 22template <class ToDuration, class Rep, class Period> 23constexpr 24ToDuration 25duration_cast(const duration<Rep, Period>& fd); 26 27template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {}; 28 29template <class Rep> inline constexpr bool treat_as_floating_point_v 30 = treat_as_floating_point<Rep>::value; // C++17 31 32template <class Rep> 33struct duration_values 34{ 35public: 36 static constexpr Rep zero(); 37 static constexpr Rep max(); 38 static constexpr Rep min(); 39}; 40 41// duration 42 43template <class Rep, class Period = ratio<1>> 44class duration 45{ 46 static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration"); 47 static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio"); 48 static_assert(Period::num > 0, "duration period must be positive"); 49public: 50 typedef Rep rep; 51 typedef 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++(); // constexpr in C++17 81 constexpr duration operator++(int); // constexpr in C++17 82 constexpr duration& operator--(); // constexpr in C++17 83 constexpr duration operator--(int); // constexpr in C++17 84 85 constexpr duration& operator+=(const duration& d); // constexpr in C++17 86 constexpr duration& operator-=(const duration& d); // constexpr in C++17 87 88 duration& operator*=(const rep& rhs); // constexpr in C++17 89 duration& operator/=(const rep& rhs); // constexpr in C++17 90 duration& operator%=(const rep& rhs); // constexpr in C++17 91 duration& operator%=(const duration& rhs); // constexpr in C++17 92 93 // special values 94 95 static constexpr duration zero(); 96 static constexpr duration min(); 97 static constexpr duration max(); 98}; 99 100typedef duration<long long, nano> nanoseconds; 101typedef duration<long long, micro> microseconds; 102typedef duration<long long, milli> milliseconds; 103typedef duration<long long > seconds; 104typedef duration< long, ratio< 60> > minutes; 105typedef duration< long, ratio<3600> > hours; 106 107template <class Clock, class Duration = typename Clock::duration> 108class time_point 109{ 110public: 111 typedef Clock clock; 112 typedef Duration duration; 113 typedef typename duration::rep rep; 114 typedef typename duration::period period; 115private: 116 duration d_; // exposition only 117 118public: 119 time_point(); // has value "epoch" // constexpr in C++14 120 explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14 121 122 // conversions 123 template <class Duration2> 124 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14 125 126 // observer 127 128 duration time_since_epoch() const; // constexpr in C++14 129 130 // arithmetic 131 132 time_point& operator+=(const duration& d); // constexpr in C++17 133 time_point& operator-=(const duration& d); // constexpr in C++17 134 135 // special values 136 137 static constexpr time_point min(); 138 static constexpr time_point max(); 139}; 140 141} // chrono 142 143// common_type traits 144template <class Rep1, class Period1, class Rep2, class Period2> 145 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>; 146 147template <class Clock, class Duration1, class Duration2> 148 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>; 149 150namespace chrono { 151 152 153template<class T> struct is_clock; // C++20 154template<class T> inline constexpr bool is_clock_v = is_clock<T>::value; // C++20 155 156 157// duration arithmetic 158template <class Rep1, class Period1, class Rep2, class Period2> 159 constexpr 160 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type 161 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 162template <class Rep1, class Period1, class Rep2, class Period2> 163 constexpr 164 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type 165 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 166template <class Rep1, class Period, class Rep2> 167 constexpr 168 duration<typename common_type<Rep1, Rep2>::type, Period> 169 operator*(const duration<Rep1, Period>& d, const Rep2& s); 170template <class Rep1, class Period, class Rep2> 171 constexpr 172 duration<typename common_type<Rep1, Rep2>::type, Period> 173 operator*(const Rep1& s, const duration<Rep2, Period>& d); 174template <class Rep1, class Period, class Rep2> 175 constexpr 176 duration<typename common_type<Rep1, Rep2>::type, Period> 177 operator/(const duration<Rep1, Period>& d, const Rep2& s); 178template <class Rep1, class Period1, class Rep2, class Period2> 179 constexpr 180 typename common_type<Rep1, Rep2>::type 181 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 182 183// duration comparisons 184template <class Rep1, class Period1, class Rep2, class Period2> 185 constexpr 186 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 187template <class Rep1, class Period1, class Rep2, class Period2> 188 constexpr 189 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 190template <class Rep1, class Period1, class Rep2, class Period2> 191 constexpr 192 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 193template <class Rep1, class Period1, class Rep2, class Period2> 194 constexpr 195 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 196template <class Rep1, class Period1, class Rep2, class Period2> 197 constexpr 198 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 199template <class Rep1, class Period1, class Rep2, class Period2> 200 constexpr 201 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); 202 203// duration_cast 204template <class ToDuration, class Rep, class Period> 205 ToDuration duration_cast(const duration<Rep, Period>& d); 206 207template <class ToDuration, class Rep, class Period> 208 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17 209template <class ToDuration, class Rep, class Period> 210 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17 211template <class ToDuration, class Rep, class Period> 212 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17 213 214// duration I/O is elsewhere 215 216// time_point arithmetic (all constexpr in C++14) 217template <class Clock, class Duration1, class Rep2, class Period2> 218 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type> 219 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); 220template <class Rep1, class Period1, class Clock, class Duration2> 221 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type> 222 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs); 223template <class Clock, class Duration1, class Rep2, class Period2> 224 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type> 225 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs); 226template <class Clock, class Duration1, class Duration2> 227 typename common_type<Duration1, Duration2>::type 228 operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 229 230// time_point comparisons (all constexpr in C++14) 231template <class Clock, class Duration1, class Duration2> 232 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 233template <class Clock, class Duration1, class Duration2> 234 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 235template <class Clock, class Duration1, class Duration2> 236 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 237template <class Clock, class Duration1, class Duration2> 238 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 239template <class Clock, class Duration1, class Duration2> 240 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 241template <class Clock, class Duration1, class Duration2> 242 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); 243 244// time_point_cast (constexpr in C++14) 245 246template <class ToDuration, class Clock, class Duration> 247 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t); 248 249template <class ToDuration, class Clock, class Duration> 250 constexpr time_point<Clock, ToDuration> 251 floor(const time_point<Clock, Duration>& tp); // C++17 252 253template <class ToDuration, class Clock, class Duration> 254 constexpr time_point<Clock, ToDuration> 255 ceil(const time_point<Clock, Duration>& tp); // C++17 256 257template <class ToDuration, class Clock, class Duration> 258 constexpr time_point<Clock, ToDuration> 259 round(const time_point<Clock, Duration>& tp); // C++17 260 261template <class Rep, class Period> 262 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17 263 264// Clocks 265 266class system_clock 267{ 268public: 269 typedef microseconds duration; 270 typedef duration::rep rep; 271 typedef duration::period period; 272 typedef chrono::time_point<system_clock> time_point; 273 static const bool is_steady = false; // constexpr in C++14 274 275 static time_point now() noexcept; 276 static time_t to_time_t (const time_point& __t) noexcept; 277 static time_point from_time_t(time_t __t) noexcept; 278}; 279 280template <class Duration> 281 using sys_time = time_point<system_clock, Duration>; // C++20 282using sys_seconds = sys_time<seconds>; // C++20 283using sys_days = sys_time<days>; // C++20 284 285class utc_clock; // C++20 286 287template <class Duration> 288 using utc_time = time_point<utc_clock, Duration>; // C++20 289using utc_seconds = utc_time<seconds>; // C++20 290 291class tai_clock; // C++20 292 293template <class Duration> 294 using tai_time = time_point<tai_clock, Duration>; // C++20 295using tai_seconds = tai_time<seconds>; // C++20 296 297class file_clock; // C++20 298 299template<class Duration> 300 using file_time = time_point<file_clock, Duration>; // C++20 301 302class steady_clock 303{ 304public: 305 typedef nanoseconds duration; 306 typedef duration::rep rep; 307 typedef duration::period period; 308 typedef chrono::time_point<steady_clock, duration> time_point; 309 static const bool is_steady = true; // constexpr in C++14 310 311 static time_point now() noexcept; 312}; 313 314typedef steady_clock high_resolution_clock; 315 316// 25.7.8, local time // C++20 317struct local_t {}; 318template<class Duration> 319 using local_time = time_point<local_t, Duration>; 320using local_seconds = local_time<seconds>; 321using local_days = local_time<days>; 322 323// 25.7.9, time_point conversions template<class DestClock, class SourceClock> // C++20 324struct clock_time_conversion; 325 326template<class DestClock, class SourceClock, class Duration> 327 auto clock_cast(const time_point<SourceClock, Duration>& t); 328 329// 25.8.2, class last_spec // C++20 330struct last_spec; 331 332// 25.8.3, class day // C++20 333 334class day; 335constexpr bool operator==(const day& x, const day& y) noexcept; 336constexpr bool operator!=(const day& x, const day& y) noexcept; 337constexpr bool operator< (const day& x, const day& y) noexcept; 338constexpr bool operator> (const day& x, const day& y) noexcept; 339constexpr bool operator<=(const day& x, const day& y) noexcept; 340constexpr bool operator>=(const day& x, const day& y) noexcept; 341constexpr day operator+(const day& x, const days& y) noexcept; 342constexpr day operator+(const days& x, const day& y) noexcept; 343constexpr day operator-(const day& x, const days& y) noexcept; 344constexpr days operator-(const day& x, const day& y) noexcept; 345 346// 25.8.4, class month // C++20 347class month; 348constexpr bool operator==(const month& x, const month& y) noexcept; 349constexpr bool operator!=(const month& x, const month& y) noexcept; 350constexpr bool operator< (const month& x, const month& y) noexcept; 351constexpr bool operator> (const month& x, const month& y) noexcept; 352constexpr bool operator<=(const month& x, const month& y) noexcept; 353constexpr bool operator>=(const month& x, const month& y) noexcept; 354constexpr month operator+(const month& x, const months& y) noexcept; 355constexpr month operator+(const months& x, const month& y) noexcept; 356constexpr month operator-(const month& x, const months& y) noexcept; 357constexpr months operator-(const month& x, const month& y) noexcept; 358 359// 25.8.5, class year // C++20 360class year; 361constexpr bool operator==(const year& x, const year& y) noexcept; 362constexpr bool operator!=(const year& x, const year& y) noexcept; 363constexpr bool operator< (const year& x, const year& y) noexcept; 364constexpr bool operator> (const year& x, const year& y) noexcept; 365constexpr bool operator<=(const year& x, const year& y) noexcept; 366constexpr bool operator>=(const year& x, const year& y) noexcept; 367constexpr year operator+(const year& x, const years& y) noexcept; 368constexpr year operator+(const years& x, const year& y) noexcept; 369constexpr year operator-(const year& x, const years& y) noexcept; 370constexpr years operator-(const year& x, const year& y) noexcept; 371 372// 25.8.6, class weekday // C++20 373class weekday; 374 375constexpr bool operator==(const weekday& x, const weekday& y) noexcept; 376constexpr bool operator!=(const weekday& x, const weekday& y) noexcept; 377constexpr weekday operator+(const weekday& x, const days& y) noexcept; 378constexpr weekday operator+(const days& x, const weekday& y) noexcept; 379constexpr weekday operator-(const weekday& x, const days& y) noexcept; 380constexpr days operator-(const weekday& x, const weekday& y) noexcept; 381 382// 25.8.7, class weekday_indexed // C++20 383 384class weekday_indexed; 385constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept; 386constexpr bool operator!=(const weekday_indexed& x, const weekday_indexed& y) noexcept; 387 388// 25.8.8, class weekday_last // C++20 389class weekday_last; 390 391constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept; 392constexpr bool operator!=(const weekday_last& x, const weekday_last& y) noexcept; 393 394// 25.8.9, class month_day // C++20 395class month_day; 396 397constexpr bool operator==(const month_day& x, const month_day& y) noexcept; 398constexpr bool operator!=(const month_day& x, const month_day& y) noexcept; 399constexpr bool operator< (const month_day& x, const month_day& y) noexcept; 400constexpr bool operator> (const month_day& x, const month_day& y) noexcept; 401constexpr bool operator<=(const month_day& x, const month_day& y) noexcept; 402constexpr bool operator>=(const month_day& x, const month_day& y) noexcept; 403 404 405// 25.8.10, class month_day_last // C++20 406class month_day_last; 407 408constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept; 409constexpr bool operator!=(const month_day_last& x, const month_day_last& y) noexcept; 410constexpr bool operator< (const month_day_last& x, const month_day_last& y) noexcept; 411constexpr bool operator> (const month_day_last& x, const month_day_last& y) noexcept; 412constexpr bool operator<=(const month_day_last& x, const month_day_last& y) noexcept; 413constexpr bool operator>=(const month_day_last& x, const month_day_last& y) noexcept; 414 415// 25.8.11, class month_weekday // C++20 416class month_weekday; 417 418constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept; 419constexpr bool operator!=(const month_weekday& x, const month_weekday& y) noexcept; 420 421// 25.8.12, class month_weekday_last // C++20 422class month_weekday_last; 423 424constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept; 425constexpr bool operator!=(const month_weekday_last& x, const month_weekday_last& y) noexcept; 426 427 428// 25.8.13, class year_month // C++20 429class year_month; 430 431constexpr bool operator==(const year_month& x, const year_month& y) noexcept; 432constexpr bool operator!=(const year_month& x, const year_month& y) noexcept; 433constexpr bool operator< (const year_month& x, const year_month& y) noexcept; 434constexpr bool operator> (const year_month& x, const year_month& y) noexcept; 435constexpr bool operator<=(const year_month& x, const year_month& y) noexcept; 436constexpr bool operator>=(const year_month& x, const year_month& y) noexcept; 437 438constexpr year_month operator+(const year_month& ym, const months& dm) noexcept; 439constexpr year_month operator+(const months& dm, const year_month& ym) noexcept; 440constexpr year_month operator-(const year_month& ym, const months& dm) noexcept; 441constexpr months operator-(const year_month& x, const year_month& y) noexcept; 442constexpr year_month operator+(const year_month& ym, const years& dy) noexcept; 443constexpr year_month operator+(const years& dy, const year_month& ym) noexcept; 444constexpr year_month operator-(const year_month& ym, const years& dy) noexcept; 445 446// 25.8.14, class year_month_day class // C++20 447year_month_day; 448 449constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept; 450constexpr bool operator!=(const year_month_day& x, const year_month_day& y) noexcept; 451constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept; 452constexpr bool operator> (const year_month_day& x, const year_month_day& y) noexcept; 453constexpr bool operator<=(const year_month_day& x, const year_month_day& y) noexcept; 454constexpr bool operator>=(const year_month_day& x, const year_month_day& y) noexcept; 455 456constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept; 457constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept; 458constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept; 459constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept; 460constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept; 461constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept; 462 463 464// 25.8.15, class year_month_day_last // C++20 465class year_month_day_last; 466 467constexpr bool operator==(const year_month_day_last& x, 468 const year_month_day_last& y) noexcept; 469constexpr bool operator!=(const year_month_day_last& x, 470 const year_month_day_last& y) noexcept; 471constexpr bool operator< (const year_month_day_last& x, 472 const year_month_day_last& y) noexcept; 473constexpr bool operator> (const year_month_day_last& x, 474 const year_month_day_last& y) noexcept; 475constexpr bool operator<=(const year_month_day_last& x, 476 const year_month_day_last& y) noexcept; 477constexpr bool operator>=(const year_month_day_last& x, 478 const year_month_day_last& y) noexcept; 479 480constexpr year_month_day_last 481 operator+(const year_month_day_last& ymdl, const months& dm) noexcept; 482constexpr year_month_day_last 483 operator+(const months& dm, const year_month_day_last& ymdl) noexcept; 484constexpr year_month_day_last 485 operator+(const year_month_day_last& ymdl, const years& dy) noexcept; 486constexpr year_month_day_last 487 operator+(const years& dy, const year_month_day_last& ymdl) noexcept; 488constexpr year_month_day_last 489 operator-(const year_month_day_last& ymdl, const months& dm) noexcept; 490constexpr year_month_day_last 491 operator-(const year_month_day_last& ymdl, const years& dy) noexcept; 492 493// 25.8.16, class year_month_weekday // C++20 494class year_month_weekday; 495 496constexpr bool operator==(const year_month_weekday& x, 497 const year_month_weekday& y) noexcept; 498constexpr bool operator!=(const year_month_weekday& x, 499 const year_month_weekday& y) noexcept; 500 501constexpr year_month_weekday 502 operator+(const year_month_weekday& ymwd, const months& dm) noexcept; 503constexpr year_month_weekday 504 operator+(const months& dm, const year_month_weekday& ymwd) noexcept; 505constexpr year_month_weekday 506 operator+(const year_month_weekday& ymwd, const years& dy) noexcept; 507constexpr year_month_weekday 508 operator+(const years& dy, const year_month_weekday& ymwd) noexcept; 509constexpr year_month_weekday 510 operator-(const year_month_weekday& ymwd, const months& dm) noexcept; 511constexpr year_month_weekday 512 operator-(const year_month_weekday& ymwd, const years& dy) noexcept; 513 514// 25.8.17, class year_month_weekday_last // C++20 515class year_month_weekday_last; 516 517constexpr bool operator==(const year_month_weekday_last& x, 518 const year_month_weekday_last& y) noexcept; 519constexpr bool operator!=(const year_month_weekday_last& x, 520 const year_month_weekday_last& y) noexcept; 521constexpr year_month_weekday_last 522 operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept; 523constexpr year_month_weekday_last 524 operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept; 525constexpr year_month_weekday_last 526 operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept; 527constexpr year_month_weekday_last 528 operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept; 529constexpr year_month_weekday_last 530 operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept; 531constexpr year_month_weekday_last 532 operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept; 533 534// 25.8.18, civil calendar conventional syntax operators // C++20 535constexpr year_month 536 operator/(const year& y, const month& m) noexcept; 537constexpr year_month 538 operator/(const year& y, int m) noexcept; 539constexpr month_day 540 operator/(const month& m, const day& d) noexcept; 541constexpr month_day 542 operator/(const month& m, int d) noexcept; 543constexpr month_day 544 operator/(int m, const day& d) noexcept; 545constexpr month_day 546 operator/(const day& d, const month& m) noexcept; 547constexpr month_day 548 operator/(const day& d, int m) noexcept; 549constexpr month_day_last 550 operator/(const month& m, last_spec) noexcept; 551constexpr month_day_last 552 operator/(int m, last_spec) noexcept; 553constexpr month_day_last 554 operator/(last_spec, const month& m) noexcept; 555constexpr month_day_last 556 operator/(last_spec, int m) noexcept; 557constexpr month_weekday 558 operator/(const month& m, const weekday_indexed& wdi) noexcept; 559constexpr month_weekday 560 operator/(int m, const weekday_indexed& wdi) noexcept; 561constexpr month_weekday 562 operator/(const weekday_indexed& wdi, const month& m) noexcept; 563constexpr month_weekday 564 operator/(const weekday_indexed& wdi, int m) noexcept; 565constexpr month_weekday_last 566 operator/(const month& m, const weekday_last& wdl) noexcept; 567constexpr month_weekday_last 568 operator/(int m, const weekday_last& wdl) noexcept; 569constexpr month_weekday_last 570 operator/(const weekday_last& wdl, const month& m) noexcept; 571constexpr month_weekday_last 572 operator/(const weekday_last& wdl, int m) noexcept; 573constexpr year_month_day 574 operator/(const year_month& ym, const day& d) noexcept; 575constexpr year_month_day 576 operator/(const year_month& ym, int d) noexcept; 577constexpr year_month_day 578 operator/(const year& y, const month_day& md) noexcept; 579constexpr year_month_day 580 operator/(int y, const month_day& md) noexcept; 581constexpr year_month_day 582 operator/(const month_day& md, const year& y) noexcept; 583constexpr year_month_day 584 operator/(const month_day& md, int y) noexcept; 585constexpr year_month_day_last 586 operator/(const year_month& ym, last_spec) noexcept; 587constexpr year_month_day_last 588 operator/(const year& y, const month_day_last& mdl) noexcept; 589constexpr year_month_day_last 590 operator/(int y, const month_day_last& mdl) noexcept; 591constexpr year_month_day_last 592 operator/(const month_day_last& mdl, const year& y) noexcept; 593constexpr year_month_day_last 594 operator/(const month_day_last& mdl, int y) noexcept; 595constexpr year_month_weekday 596 operator/(const year_month& ym, const weekday_indexed& wdi) noexcept; 597constexpr year_month_weekday 598 operator/(const year& y, const month_weekday& mwd) noexcept; 599constexpr year_month_weekday 600 operator/(int y, const month_weekday& mwd) noexcept; 601constexpr year_month_weekday 602 operator/(const month_weekday& mwd, const year& y) noexcept; 603constexpr year_month_weekday 604 operator/(const month_weekday& mwd, int y) noexcept; 605constexpr year_month_weekday_last 606 operator/(const year_month& ym, const weekday_last& wdl) noexcept; 607constexpr year_month_weekday_last 608 operator/(const year& y, const month_weekday_last& mwdl) noexcept; 609constexpr year_month_weekday_last 610 operator/(int y, const month_weekday_last& mwdl) noexcept; 611constexpr year_month_weekday_last 612 operator/(const month_weekday_last& mwdl, const year& y) noexcept; 613constexpr year_month_weekday_last 614 operator/(const month_weekday_last& mwdl, int y) noexcept; 615 616// 25.9, class template time_of_day // C++20 617template<class Duration> class time_of_day; 618 619template<> class time_of_day<hours>; 620template<> class time_of_day<minutes>; 621template<> class time_of_day<seconds>; 622template<class Rep, class Period> class time_of_day<duration<Rep, Period>>; 623 624// 25.10.2, time zone database // C++20 625struct tzdb; 626class tzdb_list; 627 628// 25.10.2.3, time zone database access // C++20 629const tzdb& get_tzdb(); 630tzdb_list& get_tzdb_list(); 631const time_zone* locate_zone(string_view tz_name); 632const time_zone* current_zone(); 633 634// 25.10.2.4, remote time zone database support // C++20 635const tzdb& reload_tzdb(); 636string remote_version(); 637 638// 25.10.3, exception classes // C++20 639class nonexistent_local_time; 640class ambiguous_local_time; 641 642// 25.10.4, information classes // C++20 643struct sys_info; 644struct local_info; 645 646// 25.10.5, class time_zone // C++20 647enum class choose {earliest, latest}; 648class time_zone; 649bool operator==(const time_zone& x, const time_zone& y) noexcept; 650bool operator!=(const time_zone& x, const time_zone& y) noexcept; 651bool operator<(const time_zone& x, const time_zone& y) noexcept; 652bool operator>(const time_zone& x, const time_zone& y) noexcept; 653bool operator<=(const time_zone& x, const time_zone& y) noexcept; 654bool operator>=(const time_zone& x, const time_zone& y) noexcept; 655 656// 25.10.6, class template zoned_traits // C++20 657template<class T> struct zoned_traits; 658 659// 25.10.7, class template zoned_time // C++20 660template<class Duration, class TimeZonePtr = const time_zone*> class zoned_time; 661using zoned_seconds = zoned_time<seconds>; 662 663template<class Duration1, class Duration2, class TimeZonePtr> 664 bool operator==(const zoned_time<Duration1, TimeZonePtr>& x, 665 const zoned_time<Duration2, TimeZonePtr>& y); 666template<class Duration1, class Duration2, class TimeZonePtr> 667 bool operator!=(const zoned_time<Duration1, TimeZonePtr>& x, 668 const zoned_time<Duration2, TimeZonePtr>& y); 669 670// 25.10.8, leap second support // C++20 671class leap; 672 673bool operator==(const leap& x, const leap& y); 674bool operator!=(const leap& x, const leap& y); 675bool operator< (const leap& x, const leap& y); 676bool operator> (const leap& x, const leap& y); 677bool operator<=(const leap& x, const leap& y); 678bool operator>=(const leap& x, const leap& y); 679template<class Duration> 680 bool operator==(const leap& x, const sys_time<Duration>& y); 681template<class Duration> 682 bool operator==(const sys_time<Duration>& x, const leap& y); 683template<class Duration> 684 bool operator!=(const leap& x, const sys_time<Duration>& y); 685template<class Duration> 686 bool operator!=(const sys_time<Duration>& x, const leap& y); 687template<class Duration> 688 bool operator< (const leap& x, const sys_time<Duration>& y); 689template<class Duration> 690 bool operator< (const sys_time<Duration>& x, const leap& y); 691template<class Duration> 692 bool operator> (const leap& x, const sys_time<Duration>& y); 693template<class Duration> 694 bool operator> (const sys_time<Duration>& x, const leap& y); 695template<class Duration> 696 bool operator<=(const leap& x, const sys_time<Duration>& y); 697template<class Duration> 698 bool operator<=(const sys_time<Duration>& x, const leap& y); 699template<class Duration> 700 bool operator>=(const leap& x, const sys_time<Duration>& y); 701template<class Duration> 702 bool operator>=(const sys_time<Duration>& x, const leap& y); 703 704// 25.10.9, class link // C++20 705class link; 706bool operator==(const link& x, const link& y); 707bool operator!=(const link& x, const link& y); 708bool operator< (const link& x, const link& y); 709bool operator> (const link& x, const link& y); 710bool operator<=(const link& x, const link& y); 711bool operator>=(const link& x, const link& y); 712 713// 25.11, formatting // C++20 714template<class charT, class Streamable> 715 basic_string<charT> 716 format(const charT* fmt, const Streamable& s); 717 718template<class charT, class Streamable> 719 basic_string<charT> 720 format(const locale& loc, const charT* fmt, const Streamable& s); 721 722template<class charT, class traits, class Alloc, class Streamable> 723 basic_string<charT, traits, Alloc> 724 format(const basic_string<charT, traits, Alloc>& fmt, const Streamable& s); 725 726template<class charT, class traits, class Alloc, class Streamable> 727 basic_string<charT, traits, Alloc> 728 format(const locale& loc, const basic_string<charT, traits, Alloc>& fmt, 729 const Streamable& s); 730 731// 25.12, parsing // C++20 732template<class charT, class traits, class Alloc, class Parsable> 733unspecified 734 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp); 735 736template<class charT, class traits, class Alloc, class Parsable> 737unspecified 738 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp, 739 basic_string<charT, traits, Alloc>& abbrev); 740 741template<class charT, class traits, class Alloc, class Parsable> 742unspecified 743 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp, 744 minutes& offset); 745 746template<class charT, class traits, class Alloc, class Parsable> 747unspecified 748 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp, 749 basic_string<charT, traits, Alloc>& abbrev, minutes& offset); 750 751// calendrical constants 752inline constexpr last_spec last{}; // C++20 753inline constexpr chrono::weekday Sunday{0}; // C++20 754inline constexpr chrono::weekday Monday{1}; // C++20 755inline constexpr chrono::weekday Tuesday{2}; // C++20 756inline constexpr chrono::weekday Wednesday{3}; // C++20 757inline constexpr chrono::weekday Thursday{4}; // C++20 758inline constexpr chrono::weekday Friday{5}; // C++20 759inline constexpr chrono::weekday Saturday{6}; // C++20 760 761inline constexpr chrono::month January{1}; // C++20 762inline constexpr chrono::month February{2}; // C++20 763inline constexpr chrono::month March{3}; // C++20 764inline constexpr chrono::month April{4}; // C++20 765inline constexpr chrono::month May{5}; // C++20 766inline constexpr chrono::month June{6}; // C++20 767inline constexpr chrono::month July{7}; // C++20 768inline constexpr chrono::month August{8}; // C++20 769inline constexpr chrono::month September{9}; // C++20 770inline constexpr chrono::month October{10}; // C++20 771inline constexpr chrono::month November{11}; // C++20 772inline constexpr chrono::month December{12}; // C++20 773} // chrono 774 775inline namespace literals { 776 inline namespace chrono_literals { 777constexpr chrono::hours operator ""h(unsigned long long); // C++14 778constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14 779constexpr chrono::minutes operator ""min(unsigned long long); // C++14 780constexpr chrono::duration<unspecified , ratio<60,1>> operator ""min(long double); // C++14 781constexpr chrono::seconds operator ""s(unsigned long long); // C++14 782constexpr chrono::duration<unspecified > operator ""s(long double); // C++14 783constexpr chrono::milliseconds operator ""ms(unsigned long long); // C++14 784constexpr chrono::duration<unspecified , milli> operator ""ms(long double); // C++14 785constexpr chrono::microseconds operator ""us(unsigned long long); // C++14 786constexpr chrono::duration<unspecified , micro> operator ""us(long double); // C++14 787constexpr chrono::nanoseconds operator ""ns(unsigned long long); // C++14 788constexpr chrono::duration<unspecified , nano> operator ""ns(long double); // C++14 789constexpr chrono::day operator ""d(unsigned long long d) noexcept; // C++20 790constexpr chrono::year operator ""y(unsigned long long y) noexcept; // C++20 791} // chrono_literals 792} // literals 793 794} // std 795*/ 796 797#include <__config> 798#include <ctime> 799#include <type_traits> 800#include <ratio> 801#include <limits> 802#include <version> 803 804#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 805#pragma GCC system_header 806#endif 807 808_LIBCPP_PUSH_MACROS 809#include <__undef_macros> 810 811 812_LIBCPP_BEGIN_NAMESPACE_STD 813 814namespace chrono 815{ 816 817template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration; 818 819template <class _Tp> 820struct __is_duration : false_type {}; 821 822template <class _Rep, class _Period> 823struct __is_duration<duration<_Rep, _Period> > : true_type {}; 824 825template <class _Rep, class _Period> 826struct __is_duration<const duration<_Rep, _Period> > : true_type {}; 827 828template <class _Rep, class _Period> 829struct __is_duration<volatile duration<_Rep, _Period> > : true_type {}; 830 831template <class _Rep, class _Period> 832struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {}; 833 834} // chrono 835 836template <class _Rep1, class _Period1, class _Rep2, class _Period2> 837struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>, 838 chrono::duration<_Rep2, _Period2> > 839{ 840 typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, 841 typename __ratio_gcd<_Period1, _Period2>::type> type; 842}; 843 844namespace chrono { 845 846// duration_cast 847 848template <class _FromDuration, class _ToDuration, 849 class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type, 850 bool = _Period::num == 1, 851 bool = _Period::den == 1> 852struct __duration_cast; 853 854template <class _FromDuration, class _ToDuration, class _Period> 855struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true> 856{ 857 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 858 _ToDuration operator()(const _FromDuration& __fd) const 859 { 860 return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count())); 861 } 862}; 863 864template <class _FromDuration, class _ToDuration, class _Period> 865struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false> 866{ 867 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 868 _ToDuration operator()(const _FromDuration& __fd) const 869 { 870 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; 871 return _ToDuration(static_cast<typename _ToDuration::rep>( 872 static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den))); 873 } 874}; 875 876template <class _FromDuration, class _ToDuration, class _Period> 877struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true> 878{ 879 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 880 _ToDuration operator()(const _FromDuration& __fd) const 881 { 882 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; 883 return _ToDuration(static_cast<typename _ToDuration::rep>( 884 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num))); 885 } 886}; 887 888template <class _FromDuration, class _ToDuration, class _Period> 889struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false> 890{ 891 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 892 _ToDuration operator()(const _FromDuration& __fd) const 893 { 894 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct; 895 return _ToDuration(static_cast<typename _ToDuration::rep>( 896 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num) 897 / static_cast<_Ct>(_Period::den))); 898 } 899}; 900 901template <class _ToDuration, class _Rep, class _Period> 902inline _LIBCPP_INLINE_VISIBILITY 903_LIBCPP_CONSTEXPR 904typename enable_if 905< 906 __is_duration<_ToDuration>::value, 907 _ToDuration 908>::type 909duration_cast(const duration<_Rep, _Period>& __fd) 910{ 911 return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd); 912} 913 914template <class _Rep> 915struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {}; 916 917#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES) 918template <class _Rep> 919_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool treat_as_floating_point_v 920 = treat_as_floating_point<_Rep>::value; 921#endif 922 923template <class _Rep> 924struct _LIBCPP_TEMPLATE_VIS duration_values 925{ 926public: 927 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);} 928 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() {return numeric_limits<_Rep>::max();} 929 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numeric_limits<_Rep>::lowest();} 930}; 931 932#if _LIBCPP_STD_VER > 14 933template <class _ToDuration, class _Rep, class _Period> 934inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 935typename enable_if 936< 937 __is_duration<_ToDuration>::value, 938 _ToDuration 939>::type 940floor(const duration<_Rep, _Period>& __d) 941{ 942 _ToDuration __t = duration_cast<_ToDuration>(__d); 943 if (__t > __d) 944 __t = __t - _ToDuration{1}; 945 return __t; 946} 947 948template <class _ToDuration, class _Rep, class _Period> 949inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 950typename enable_if 951< 952 __is_duration<_ToDuration>::value, 953 _ToDuration 954>::type 955ceil(const duration<_Rep, _Period>& __d) 956{ 957 _ToDuration __t = duration_cast<_ToDuration>(__d); 958 if (__t < __d) 959 __t = __t + _ToDuration{1}; 960 return __t; 961} 962 963template <class _ToDuration, class _Rep, class _Period> 964inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 965typename enable_if 966< 967 __is_duration<_ToDuration>::value, 968 _ToDuration 969>::type 970round(const duration<_Rep, _Period>& __d) 971{ 972 _ToDuration __lower = floor<_ToDuration>(__d); 973 _ToDuration __upper = __lower + _ToDuration{1}; 974 auto __lowerDiff = __d - __lower; 975 auto __upperDiff = __upper - __d; 976 if (__lowerDiff < __upperDiff) 977 return __lower; 978 if (__lowerDiff > __upperDiff) 979 return __upper; 980 return __lower.count() & 1 ? __upper : __lower; 981} 982#endif 983 984// duration 985 986template <class _Rep, class _Period> 987class _LIBCPP_TEMPLATE_VIS duration 988{ 989 static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration"); 990 static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio"); 991 static_assert(_Period::num > 0, "duration period must be positive"); 992 993 template <class _R1, class _R2> 994 struct __no_overflow 995 { 996 private: 997 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value; 998 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value; 999 static const intmax_t __n1 = _R1::num / __gcd_n1_n2; 1000 static const intmax_t __d1 = _R1::den / __gcd_d1_d2; 1001 static const intmax_t __n2 = _R2::num / __gcd_n1_n2; 1002 static const intmax_t __d2 = _R2::den / __gcd_d1_d2; 1003 static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1); 1004 1005 template <intmax_t _Xp, intmax_t _Yp, bool __overflow> 1006 struct __mul // __overflow == false 1007 { 1008 static const intmax_t value = _Xp * _Yp; 1009 }; 1010 1011 template <intmax_t _Xp, intmax_t _Yp> 1012 struct __mul<_Xp, _Yp, true> 1013 { 1014 static const intmax_t value = 1; 1015 }; 1016 1017 public: 1018 static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1); 1019 typedef ratio<__mul<__n1, __d2, !value>::value, 1020 __mul<__n2, __d1, !value>::value> type; 1021 }; 1022 1023public: 1024 typedef _Rep rep; 1025 typedef typename _Period::type period; 1026private: 1027 rep __rep_; 1028public: 1029 1030 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1031#ifndef _LIBCPP_CXX03_LANG 1032 duration() = default; 1033#else 1034 duration() {} 1035#endif 1036 1037 template <class _Rep2> 1038 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1039 explicit duration(const _Rep2& __r, 1040 typename enable_if 1041 < 1042 is_convertible<_Rep2, rep>::value && 1043 (treat_as_floating_point<rep>::value || 1044 !treat_as_floating_point<_Rep2>::value) 1045 >::type* = 0) 1046 : __rep_(__r) {} 1047 1048 // conversions 1049 template <class _Rep2, class _Period2> 1050 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1051 duration(const duration<_Rep2, _Period2>& __d, 1052 typename enable_if 1053 < 1054 __no_overflow<_Period2, period>::value && ( 1055 treat_as_floating_point<rep>::value || 1056 (__no_overflow<_Period2, period>::type::den == 1 && 1057 !treat_as_floating_point<_Rep2>::value)) 1058 >::type* = 0) 1059 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {} 1060 1061 // observer 1062 1063 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;} 1064 1065 // arithmetic 1066 1067 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);} 1068 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);} 1069 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;} 1070 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);} 1071 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;} 1072 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);} 1073 1074 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;} 1075 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;} 1076 1077 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;} 1078 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;} 1079 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;} 1080 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;} 1081 1082 // special values 1083 1084 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());} 1085 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return duration(duration_values<rep>::min());} 1086 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return duration(duration_values<rep>::max());} 1087}; 1088 1089typedef duration<long long, nano> nanoseconds; 1090typedef duration<long long, micro> microseconds; 1091typedef duration<long long, milli> milliseconds; 1092typedef duration<long long > seconds; 1093typedef duration< long, ratio< 60> > minutes; 1094typedef duration< long, ratio<3600> > hours; 1095#if _LIBCPP_STD_VER > 17 1096typedef duration< int, ratio_multiply<ratio<24>, hours::period>> days; 1097typedef duration< int, ratio_multiply<ratio<7>, days::period>> weeks; 1098typedef duration< int, ratio_multiply<ratio<146097, 400>, days::period>> years; 1099typedef duration< int, ratio_divide<years::period, ratio<12>>> months; 1100#endif 1101// Duration == 1102 1103template <class _LhsDuration, class _RhsDuration> 1104struct __duration_eq 1105{ 1106 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1107 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const 1108 { 1109 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; 1110 return _Ct(__lhs).count() == _Ct(__rhs).count(); 1111 } 1112}; 1113 1114template <class _LhsDuration> 1115struct __duration_eq<_LhsDuration, _LhsDuration> 1116{ 1117 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1118 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const 1119 {return __lhs.count() == __rhs.count();} 1120}; 1121 1122template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1123inline _LIBCPP_INLINE_VISIBILITY 1124_LIBCPP_CONSTEXPR 1125bool 1126operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1127{ 1128 return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); 1129} 1130 1131// Duration != 1132 1133template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1134inline _LIBCPP_INLINE_VISIBILITY 1135_LIBCPP_CONSTEXPR 1136bool 1137operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1138{ 1139 return !(__lhs == __rhs); 1140} 1141 1142// Duration < 1143 1144template <class _LhsDuration, class _RhsDuration> 1145struct __duration_lt 1146{ 1147 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1148 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const 1149 { 1150 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct; 1151 return _Ct(__lhs).count() < _Ct(__rhs).count(); 1152 } 1153}; 1154 1155template <class _LhsDuration> 1156struct __duration_lt<_LhsDuration, _LhsDuration> 1157{ 1158 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1159 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const 1160 {return __lhs.count() < __rhs.count();} 1161}; 1162 1163template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1164inline _LIBCPP_INLINE_VISIBILITY 1165_LIBCPP_CONSTEXPR 1166bool 1167operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1168{ 1169 return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs); 1170} 1171 1172// Duration > 1173 1174template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1175inline _LIBCPP_INLINE_VISIBILITY 1176_LIBCPP_CONSTEXPR 1177bool 1178operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1179{ 1180 return __rhs < __lhs; 1181} 1182 1183// Duration <= 1184 1185template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1186inline _LIBCPP_INLINE_VISIBILITY 1187_LIBCPP_CONSTEXPR 1188bool 1189operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1190{ 1191 return !(__rhs < __lhs); 1192} 1193 1194// Duration >= 1195 1196template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1197inline _LIBCPP_INLINE_VISIBILITY 1198_LIBCPP_CONSTEXPR 1199bool 1200operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1201{ 1202 return !(__lhs < __rhs); 1203} 1204 1205// Duration + 1206 1207template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1208inline _LIBCPP_INLINE_VISIBILITY 1209_LIBCPP_CONSTEXPR 1210typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 1211operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1212{ 1213 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 1214 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count()); 1215} 1216 1217// Duration - 1218 1219template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1220inline _LIBCPP_INLINE_VISIBILITY 1221_LIBCPP_CONSTEXPR 1222typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 1223operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1224{ 1225 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 1226 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count()); 1227} 1228 1229// Duration * 1230 1231template <class _Rep1, class _Period, class _Rep2> 1232inline _LIBCPP_INLINE_VISIBILITY 1233_LIBCPP_CONSTEXPR 1234typename enable_if 1235< 1236 is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value, 1237 duration<typename common_type<_Rep1, _Rep2>::type, _Period> 1238>::type 1239operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 1240{ 1241 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 1242 typedef duration<_Cr, _Period> _Cd; 1243 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s)); 1244} 1245 1246template <class _Rep1, class _Period, class _Rep2> 1247inline _LIBCPP_INLINE_VISIBILITY 1248_LIBCPP_CONSTEXPR 1249typename enable_if 1250< 1251 is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value, 1252 duration<typename common_type<_Rep1, _Rep2>::type, _Period> 1253>::type 1254operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) 1255{ 1256 return __d * __s; 1257} 1258 1259// Duration / 1260 1261template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value> 1262struct __duration_divide_result 1263{ 1264}; 1265 1266template <class _Duration, class _Rep2, 1267 bool = is_convertible<_Rep2, 1268 typename common_type<typename _Duration::rep, _Rep2>::type>::value> 1269struct __duration_divide_imp 1270{ 1271}; 1272 1273template <class _Rep1, class _Period, class _Rep2> 1274struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true> 1275{ 1276 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type; 1277}; 1278 1279template <class _Rep1, class _Period, class _Rep2> 1280struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false> 1281 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2> 1282{ 1283}; 1284 1285template <class _Rep1, class _Period, class _Rep2> 1286inline _LIBCPP_INLINE_VISIBILITY 1287_LIBCPP_CONSTEXPR 1288typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 1289operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 1290{ 1291 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 1292 typedef duration<_Cr, _Period> _Cd; 1293 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s)); 1294} 1295 1296template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1297inline _LIBCPP_INLINE_VISIBILITY 1298_LIBCPP_CONSTEXPR 1299typename common_type<_Rep1, _Rep2>::type 1300operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1301{ 1302 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct; 1303 return _Ct(__lhs).count() / _Ct(__rhs).count(); 1304} 1305 1306// Duration % 1307 1308template <class _Rep1, class _Period, class _Rep2> 1309inline _LIBCPP_INLINE_VISIBILITY 1310_LIBCPP_CONSTEXPR 1311typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type 1312operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) 1313{ 1314 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 1315 typedef duration<_Cr, _Period> _Cd; 1316 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s)); 1317} 1318 1319template <class _Rep1, class _Period1, class _Rep2, class _Period2> 1320inline _LIBCPP_INLINE_VISIBILITY 1321_LIBCPP_CONSTEXPR 1322typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type 1323operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1324{ 1325 typedef typename common_type<_Rep1, _Rep2>::type _Cr; 1326 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd; 1327 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count())); 1328} 1329 1330////////////////////////////////////////////////////////// 1331///////////////////// time_point ///////////////////////// 1332////////////////////////////////////////////////////////// 1333 1334template <class _Clock, class _Duration = typename _Clock::duration> 1335class _LIBCPP_TEMPLATE_VIS time_point 1336{ 1337 static_assert(__is_duration<_Duration>::value, 1338 "Second template parameter of time_point must be a std::chrono::duration"); 1339public: 1340 typedef _Clock clock; 1341 typedef _Duration duration; 1342 typedef typename duration::rep rep; 1343 typedef typename duration::period period; 1344private: 1345 duration __d_; 1346 1347public: 1348 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {} 1349 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {} 1350 1351 // conversions 1352 template <class _Duration2> 1353 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1354 time_point(const time_point<clock, _Duration2>& t, 1355 typename enable_if 1356 < 1357 is_convertible<_Duration2, duration>::value 1358 >::type* = 0) 1359 : __d_(t.time_since_epoch()) {} 1360 1361 // observer 1362 1363 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;} 1364 1365 // arithmetic 1366 1367 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator+=(const duration& __d) {__d_ += __d; return *this;} 1368 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;} 1369 1370 // special values 1371 1372 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());} 1373 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());} 1374}; 1375 1376} // chrono 1377 1378template <class _Clock, class _Duration1, class _Duration2> 1379struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>, 1380 chrono::time_point<_Clock, _Duration2> > 1381{ 1382 typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type; 1383}; 1384 1385namespace chrono { 1386 1387template <class _ToDuration, class _Clock, class _Duration> 1388inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1389time_point<_Clock, _ToDuration> 1390time_point_cast(const time_point<_Clock, _Duration>& __t) 1391{ 1392 return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch())); 1393} 1394 1395#if _LIBCPP_STD_VER > 14 1396template <class _ToDuration, class _Clock, class _Duration> 1397inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1398typename enable_if 1399< 1400 __is_duration<_ToDuration>::value, 1401 time_point<_Clock, _ToDuration> 1402>::type 1403floor(const time_point<_Clock, _Duration>& __t) 1404{ 1405 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())}; 1406} 1407 1408template <class _ToDuration, class _Clock, class _Duration> 1409inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1410typename enable_if 1411< 1412 __is_duration<_ToDuration>::value, 1413 time_point<_Clock, _ToDuration> 1414>::type 1415ceil(const time_point<_Clock, _Duration>& __t) 1416{ 1417 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())}; 1418} 1419 1420template <class _ToDuration, class _Clock, class _Duration> 1421inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1422typename enable_if 1423< 1424 __is_duration<_ToDuration>::value, 1425 time_point<_Clock, _ToDuration> 1426>::type 1427round(const time_point<_Clock, _Duration>& __t) 1428{ 1429 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())}; 1430} 1431 1432template <class _Rep, class _Period> 1433inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR 1434typename enable_if 1435< 1436 numeric_limits<_Rep>::is_signed, 1437 duration<_Rep, _Period> 1438>::type 1439abs(duration<_Rep, _Period> __d) 1440{ 1441 return __d >= __d.zero() ? __d : -__d; 1442} 1443#endif 1444 1445// time_point == 1446 1447template <class _Clock, class _Duration1, class _Duration2> 1448inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1449bool 1450operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1451{ 1452 return __lhs.time_since_epoch() == __rhs.time_since_epoch(); 1453} 1454 1455// time_point != 1456 1457template <class _Clock, class _Duration1, class _Duration2> 1458inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1459bool 1460operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1461{ 1462 return !(__lhs == __rhs); 1463} 1464 1465// time_point < 1466 1467template <class _Clock, class _Duration1, class _Duration2> 1468inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1469bool 1470operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1471{ 1472 return __lhs.time_since_epoch() < __rhs.time_since_epoch(); 1473} 1474 1475// time_point > 1476 1477template <class _Clock, class _Duration1, class _Duration2> 1478inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1479bool 1480operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1481{ 1482 return __rhs < __lhs; 1483} 1484 1485// time_point <= 1486 1487template <class _Clock, class _Duration1, class _Duration2> 1488inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1489bool 1490operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1491{ 1492 return !(__rhs < __lhs); 1493} 1494 1495// time_point >= 1496 1497template <class _Clock, class _Duration1, class _Duration2> 1498inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1499bool 1500operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1501{ 1502 return !(__lhs < __rhs); 1503} 1504 1505// time_point operator+(time_point x, duration y); 1506 1507template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1508inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1509time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1510operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1511{ 1512 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr; 1513 return _Tr (__lhs.time_since_epoch() + __rhs); 1514} 1515 1516// time_point operator+(duration x, time_point y); 1517 1518template <class _Rep1, class _Period1, class _Clock, class _Duration2> 1519inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1520time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type> 1521operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1522{ 1523 return __rhs + __lhs; 1524} 1525 1526// time_point operator-(time_point x, duration y); 1527 1528template <class _Clock, class _Duration1, class _Rep2, class _Period2> 1529inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1530time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> 1531operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) 1532{ 1533 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret; 1534 return _Ret(__lhs.time_since_epoch() -__rhs); 1535} 1536 1537// duration operator-(time_point x, time_point y); 1538 1539template <class _Clock, class _Duration1, class _Duration2> 1540inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 1541typename common_type<_Duration1, _Duration2>::type 1542operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) 1543{ 1544 return __lhs.time_since_epoch() - __rhs.time_since_epoch(); 1545} 1546 1547////////////////////////////////////////////////////////// 1548/////////////////////// clocks /////////////////////////// 1549////////////////////////////////////////////////////////// 1550 1551class _LIBCPP_TYPE_VIS system_clock 1552{ 1553public: 1554 typedef microseconds duration; 1555 typedef duration::rep rep; 1556 typedef duration::period period; 1557 typedef chrono::time_point<system_clock> time_point; 1558 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false; 1559 1560 static time_point now() _NOEXCEPT; 1561 static time_t to_time_t (const time_point& __t) _NOEXCEPT; 1562 static time_point from_time_t(time_t __t) _NOEXCEPT; 1563}; 1564 1565#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK 1566class _LIBCPP_TYPE_VIS steady_clock 1567{ 1568public: 1569 typedef nanoseconds duration; 1570 typedef duration::rep rep; 1571 typedef duration::period period; 1572 typedef chrono::time_point<steady_clock, duration> time_point; 1573 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true; 1574 1575 static time_point now() _NOEXCEPT; 1576}; 1577 1578typedef steady_clock high_resolution_clock; 1579#else 1580typedef system_clock high_resolution_clock; 1581#endif 1582 1583#if _LIBCPP_STD_VER > 17 1584 1585struct _LIBCPP_TYPE_VIS last_spec { explicit last_spec() = default; }; 1586 1587 1588class _LIBCPP_TYPE_VIS day { 1589private: 1590 unsigned char __d; 1591public: 1592 day() = default; 1593 explicit inline constexpr day(unsigned __val) noexcept : __d(static_cast<unsigned char>(__val)) {} 1594 inline constexpr day& operator++() noexcept { ++__d; return *this; } 1595 inline constexpr day operator++(int) noexcept { day __tmp = *this; ++(*this); return __tmp; } 1596 inline constexpr day& operator--() noexcept { --__d; return *this; } 1597 inline constexpr day operator--(int) noexcept { day __tmp = *this; --(*this); return __tmp; } 1598 constexpr day& operator+=(const days& __dd) noexcept; 1599 constexpr day& operator-=(const days& __dd) noexcept; 1600 explicit inline constexpr operator unsigned() const noexcept { return __d; } 1601 inline constexpr bool ok() const noexcept { return __d >= 1 && __d <= 31; } 1602 }; 1603 1604 1605inline constexpr 1606bool operator==(const day& __lhs, const day& __rhs) noexcept 1607{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); } 1608 1609inline constexpr 1610bool operator!=(const day& __lhs, const day& __rhs) noexcept 1611{ return !(__lhs == __rhs); } 1612 1613inline constexpr 1614bool operator< (const day& __lhs, const day& __rhs) noexcept 1615{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); } 1616 1617inline constexpr 1618bool operator> (const day& __lhs, const day& __rhs) noexcept 1619{ return __rhs < __lhs; } 1620 1621inline constexpr 1622bool operator<=(const day& __lhs, const day& __rhs) noexcept 1623{ return !(__rhs < __lhs);} 1624 1625inline constexpr 1626bool operator>=(const day& __lhs, const day& __rhs) noexcept 1627{ return !(__lhs < __rhs); } 1628 1629inline constexpr 1630day operator+ (const day& __lhs, const days& __rhs) noexcept 1631{ return day(static_cast<unsigned>(__lhs) + __rhs.count()); } 1632 1633inline constexpr 1634day operator+ (const days& __lhs, const day& __rhs) noexcept 1635{ return __rhs + __lhs; } 1636 1637inline constexpr 1638day operator- (const day& __lhs, const days& __rhs) noexcept 1639{ return __lhs + -__rhs; } 1640 1641inline constexpr 1642days operator-(const day& __lhs, const day& __rhs) noexcept 1643{ return days(static_cast<int>(static_cast<unsigned>(__lhs)) - 1644 static_cast<int>(static_cast<unsigned>(__rhs))); } 1645 1646inline constexpr day& day::operator+=(const days& __dd) noexcept 1647{ *this = *this + __dd; return *this; } 1648 1649inline constexpr day& day::operator-=(const days& __dd) noexcept 1650{ *this = *this - __dd; return *this; } 1651 1652 1653class _LIBCPP_TYPE_VIS month { 1654private: 1655 unsigned char __m; 1656public: 1657 month() = default; 1658 explicit inline constexpr month(unsigned __val) noexcept : __m(static_cast<unsigned char>(__val)) {} 1659 inline constexpr month& operator++() noexcept { ++__m; return *this; } 1660 inline constexpr month operator++(int) noexcept { month __tmp = *this; ++(*this); return __tmp; } 1661 inline constexpr month& operator--() noexcept { --__m; return *this; } 1662 inline constexpr month operator--(int) noexcept { month __tmp = *this; --(*this); return __tmp; } 1663 constexpr month& operator+=(const months& __m1) noexcept; 1664 constexpr month& operator-=(const months& __m1) noexcept; 1665 explicit inline constexpr operator unsigned() const noexcept { return __m; } 1666 inline constexpr bool ok() const noexcept { return __m >= 1 && __m <= 12; } 1667}; 1668 1669 1670inline constexpr 1671bool operator==(const month& __lhs, const month& __rhs) noexcept 1672{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); } 1673 1674inline constexpr 1675bool operator!=(const month& __lhs, const month& __rhs) noexcept 1676{ return !(__lhs == __rhs); } 1677 1678inline constexpr 1679bool operator< (const month& __lhs, const month& __rhs) noexcept 1680{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); } 1681 1682inline constexpr 1683bool operator> (const month& __lhs, const month& __rhs) noexcept 1684{ return __rhs < __lhs; } 1685 1686inline constexpr 1687bool operator<=(const month& __lhs, const month& __rhs) noexcept 1688{ return !(__rhs < __lhs); } 1689 1690inline constexpr 1691bool operator>=(const month& __lhs, const month& __rhs) noexcept 1692{ return !(__lhs < __rhs); } 1693 1694inline constexpr 1695month operator+ (const month& __lhs, const months& __rhs) noexcept 1696{ 1697 auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + (__rhs.count() - 1); 1698 auto const __yr = (__mu >= 0 ? __mu : __mu - 11) / 12; 1699 return month{static_cast<unsigned>(__mu - __yr * 12 + 1)}; 1700} 1701 1702inline constexpr 1703month operator+ (const months& __lhs, const month& __rhs) noexcept 1704{ return __rhs + __lhs; } 1705 1706inline constexpr 1707month operator- (const month& __lhs, const months& __rhs) noexcept 1708{ return __lhs + -__rhs; } 1709 1710inline constexpr 1711months operator-(const month& __lhs, const month& __rhs) noexcept 1712{ 1713 auto const __dm = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs); 1714 return months(__dm <= 11 ? __dm : __dm + 12); 1715} 1716 1717inline constexpr month& month::operator+=(const months& __dm) noexcept 1718{ *this = *this + __dm; return *this; } 1719 1720inline constexpr month& month::operator-=(const months& __dm) noexcept 1721{ *this = *this - __dm; return *this; } 1722 1723 1724class _LIBCPP_TYPE_VIS year { 1725private: 1726 short __y; 1727public: 1728 year() = default; 1729 explicit inline constexpr year(int __val) noexcept : __y(static_cast<short>(__val)) {} 1730 1731 inline constexpr year& operator++() noexcept { ++__y; return *this; }; 1732 inline constexpr year operator++(int) noexcept { year __tmp = *this; ++(*this); return __tmp; }; 1733 inline constexpr year& operator--() noexcept { --__y; return *this; }; 1734 inline constexpr year operator--(int) noexcept { year __tmp = *this; --(*this); return __tmp; }; 1735 constexpr year& operator+=(const years& __dy) noexcept; 1736 constexpr year& operator-=(const years& __dy) noexcept; 1737 inline constexpr year operator+() const noexcept { return *this; } 1738 inline constexpr year operator-() const noexcept { return year{-__y}; }; 1739 1740 inline constexpr bool is_leap() const noexcept { return __y % 4 == 0 && (__y % 100 != 0 || __y % 400 == 0); } 1741 explicit inline constexpr operator int() const noexcept { return __y; } 1742 constexpr bool ok() const noexcept; 1743 static inline constexpr year min() noexcept { return year{-32767}; } 1744 static inline constexpr year max() noexcept { return year{ 32767}; } 1745}; 1746 1747 1748inline constexpr 1749bool operator==(const year& __lhs, const year& __rhs) noexcept 1750{ return static_cast<int>(__lhs) == static_cast<int>(__rhs); } 1751 1752inline constexpr 1753bool operator!=(const year& __lhs, const year& __rhs) noexcept 1754{ return !(__lhs == __rhs); } 1755 1756inline constexpr 1757bool operator< (const year& __lhs, const year& __rhs) noexcept 1758{ return static_cast<int>(__lhs) < static_cast<int>(__rhs); } 1759 1760inline constexpr 1761bool operator> (const year& __lhs, const year& __rhs) noexcept 1762{ return __rhs < __lhs; } 1763 1764inline constexpr 1765bool operator<=(const year& __lhs, const year& __rhs) noexcept 1766{ return !(__rhs < __lhs); } 1767 1768inline constexpr 1769bool operator>=(const year& __lhs, const year& __rhs) noexcept 1770{ return !(__lhs < __rhs); } 1771 1772inline constexpr 1773year operator+ (const year& __lhs, const years& __rhs) noexcept 1774{ return year(static_cast<int>(__lhs) + __rhs.count()); } 1775 1776inline constexpr 1777year operator+ (const years& __lhs, const year& __rhs) noexcept 1778{ return __rhs + __lhs; } 1779 1780inline constexpr 1781year operator- (const year& __lhs, const years& __rhs) noexcept 1782{ return __lhs + -__rhs; } 1783 1784inline constexpr 1785years operator-(const year& __lhs, const year& __rhs) noexcept 1786{ return years{static_cast<int>(__lhs) - static_cast<int>(__rhs)}; } 1787 1788 1789inline constexpr year& year::operator+=(const years& __dy) noexcept 1790{ *this = *this + __dy; return *this; } 1791 1792inline constexpr year& year::operator-=(const years& __dy) noexcept 1793{ *this = *this - __dy; return *this; } 1794 1795inline constexpr bool year::ok() const noexcept 1796{ return static_cast<int>(min()) <= __y && __y <= static_cast<int>(max()); } 1797 1798class _LIBCPP_TYPE_VIS weekday_indexed; 1799class _LIBCPP_TYPE_VIS weekday_last; 1800 1801class _LIBCPP_TYPE_VIS weekday { 1802private: 1803 unsigned char __wd; 1804public: 1805 weekday() = default; 1806 explicit inline constexpr weekday(unsigned __val) noexcept: __wd(static_cast<unsigned char>(__val)) {} 1807// inline constexpr weekday(const sys_days& dp) noexcept; 1808// explicit constexpr weekday(const local_days& dp) noexcept; 1809 inline constexpr weekday& operator++() noexcept { __wd = (__wd == 6 ? 0 : __wd + 1); return *this; } 1810 inline constexpr weekday operator++(int) noexcept { weekday __tmp = *this; ++(*this); return __tmp; } 1811 inline constexpr weekday& operator--() noexcept { __wd = (__wd == 0 ? 6 : __wd - 1); return *this; } 1812 inline constexpr weekday operator--(int) noexcept { weekday __tmp = *this; --(*this); return __tmp; } 1813 constexpr weekday& operator+=(const days& __dd) noexcept; 1814 constexpr weekday& operator-=(const days& __dd) noexcept; 1815 explicit inline constexpr operator unsigned() const noexcept { return __wd; } 1816 inline constexpr bool ok() const noexcept { return __wd <= 6; } 1817 constexpr weekday_indexed operator[](unsigned __index) const noexcept; 1818 constexpr weekday_last operator[](last_spec) const noexcept; 1819}; 1820 1821inline constexpr 1822bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept 1823{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); } 1824 1825inline constexpr 1826bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept 1827{ return !(__lhs == __rhs); } 1828 1829inline constexpr 1830bool operator< (const weekday& __lhs, const weekday& __rhs) noexcept 1831{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); } 1832 1833inline constexpr 1834bool operator> (const weekday& __lhs, const weekday& __rhs) noexcept 1835{ return __rhs < __lhs; } 1836 1837inline constexpr 1838bool operator<=(const weekday& __lhs, const weekday& __rhs) noexcept 1839{ return !(__rhs < __lhs);} 1840 1841inline constexpr 1842bool operator>=(const weekday& __lhs, const weekday& __rhs) noexcept 1843{ return !(__lhs < __rhs); } 1844 1845constexpr weekday operator+(const weekday& __lhs, const days& __rhs) noexcept 1846{ 1847 auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + __rhs.count(); 1848 auto const __yr = (__mu >= 0 ? __mu : __mu - 6) / 7; 1849 return weekday{static_cast<unsigned>(__mu - __yr * 7)}; 1850} 1851 1852constexpr weekday operator+(const days& __lhs, const weekday& __rhs) noexcept 1853{ return __rhs + __lhs; } 1854 1855constexpr weekday operator-(const weekday& __lhs, const days& __rhs) noexcept 1856{ return __lhs + -__rhs; } 1857 1858constexpr days operator-(const weekday& __lhs, const weekday& __rhs) noexcept 1859{ 1860 const int __wdu = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs); 1861 const int __wk = (__wdu >= 0 ? __wdu : __wdu-6) / 7; 1862 return days{__wdu - __wk * 7}; 1863} 1864 1865inline constexpr weekday& weekday::operator+=(const days& __dd) noexcept 1866{ *this = *this + __dd; return *this; } 1867 1868inline constexpr weekday& weekday::operator-=(const days& __dd) noexcept 1869{ *this = *this - __dd; return *this; } 1870 1871 1872class _LIBCPP_TYPE_VIS weekday_indexed { 1873private: 1874 _VSTD::chrono::weekday __wd; 1875 unsigned char __idx; 1876public: 1877 weekday_indexed() = default; 1878 inline constexpr weekday_indexed(const _VSTD::chrono::weekday& __wdval, unsigned __idxval) noexcept 1879 : __wd{__wdval}, __idx(__idxval) {} 1880 inline constexpr _VSTD::chrono::weekday weekday() const noexcept { return __wd; } 1881 inline constexpr unsigned index() const noexcept { return __idx; } 1882 inline constexpr bool ok() const noexcept { return __wd.ok() && __idx >= 1 && __idx <= 5; } 1883}; 1884 1885inline constexpr 1886bool operator==(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept 1887{ return __lhs.weekday() == __rhs.weekday() && __lhs.index() == __rhs.index(); } 1888 1889inline constexpr 1890bool operator!=(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept 1891{ return !(__lhs == __rhs); } 1892 1893 1894class _LIBCPP_TYPE_VIS weekday_last { 1895private: 1896 _VSTD::chrono::weekday __wd; 1897public: 1898 explicit constexpr weekday_last(const _VSTD::chrono::weekday& __val) noexcept 1899 : __wd{__val} {} 1900 constexpr _VSTD::chrono::weekday weekday() const noexcept { return __wd; } 1901 constexpr bool ok() const noexcept { return __wd.ok(); } 1902}; 1903 1904inline constexpr 1905bool operator==(const weekday_last& __lhs, const weekday_last& __rhs) noexcept 1906{ return __lhs.weekday() == __rhs.weekday(); } 1907 1908inline constexpr 1909bool operator!=(const weekday_last& __lhs, const weekday_last& __rhs) noexcept 1910{ return !(__lhs == __rhs); } 1911 1912inline constexpr 1913weekday_indexed weekday::operator[](unsigned __index) const noexcept { return weekday_indexed{*this, __index}; } 1914 1915inline constexpr 1916weekday_last weekday::operator[](last_spec) const noexcept { return weekday_last{*this}; } 1917 1918 1919inline constexpr last_spec last{}; 1920inline constexpr weekday Sunday{0}; 1921inline constexpr weekday Monday{1}; 1922inline constexpr weekday Tuesday{2}; 1923inline constexpr weekday Wednesday{3}; 1924inline constexpr weekday Thursday{4}; 1925inline constexpr weekday Friday{5}; 1926inline constexpr weekday Saturday{6}; 1927 1928inline constexpr month January{1}; 1929inline constexpr month February{2}; 1930inline constexpr month March{3}; 1931inline constexpr month April{4}; 1932inline constexpr month May{5}; 1933inline constexpr month June{6}; 1934inline constexpr month July{7}; 1935inline constexpr month August{8}; 1936inline constexpr month September{9}; 1937inline constexpr month October{10}; 1938inline constexpr month November{11}; 1939inline constexpr month December{12}; 1940 1941 1942class _LIBCPP_TYPE_VIS month_day { 1943private: 1944 chrono::month __m; 1945 chrono::day __d; 1946public: 1947 month_day() = default; 1948 constexpr month_day(const chrono::month& __mval, const chrono::day& __dval) noexcept 1949 : __m{__mval}, __d{__dval} {} 1950 inline constexpr chrono::month month() const noexcept { return __m; } 1951 inline constexpr chrono::day day() const noexcept { return __d; } 1952 constexpr bool ok() const noexcept; 1953}; 1954 1955inline constexpr 1956bool month_day::ok() const noexcept 1957{ 1958 if (!__m.ok()) return false; 1959 const unsigned __dval = static_cast<unsigned>(__d); 1960 if (__dval < 1 || __dval > 31) return false; 1961 if (__dval <= 29) return true; 1962// Now we've got either 30 or 31 1963 const unsigned __mval = static_cast<unsigned>(__m); 1964 if (__mval == 2) return false; 1965 if (__mval == 4 || __mval == 6 || __mval == 9 || __mval == 11) 1966 return __dval == 30; 1967 return true; 1968} 1969 1970inline constexpr 1971bool operator==(const month_day& __lhs, const month_day& __rhs) noexcept 1972{ return __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); } 1973 1974inline constexpr 1975bool operator!=(const month_day& __lhs, const month_day& __rhs) noexcept 1976{ return !(__lhs == __rhs); } 1977 1978inline constexpr 1979month_day operator/(const month& __lhs, const day& __rhs) noexcept 1980{ return month_day{__lhs, __rhs}; } 1981 1982constexpr 1983month_day operator/(const day& __lhs, const month& __rhs) noexcept 1984{ return __rhs / __lhs; } 1985 1986inline constexpr 1987month_day operator/(const month& __lhs, int __rhs) noexcept 1988{ return __lhs / day(__rhs); } 1989 1990constexpr 1991month_day operator/(int __lhs, const day& __rhs) noexcept 1992{ return month(__lhs) / __rhs; } 1993 1994constexpr 1995month_day operator/(const day& __lhs, int __rhs) noexcept 1996{ return month(__rhs) / __lhs; } 1997 1998 1999inline constexpr 2000bool operator< (const month_day& __lhs, const month_day& __rhs) noexcept 2001{ return __lhs.month() != __rhs.month() ? __lhs.month() < __rhs.month() : __lhs.day() < __rhs.day(); } 2002 2003inline constexpr 2004bool operator> (const month_day& __lhs, const month_day& __rhs) noexcept 2005{ return __rhs < __lhs; } 2006 2007inline constexpr 2008bool operator<=(const month_day& __lhs, const month_day& __rhs) noexcept 2009{ return !(__rhs < __lhs);} 2010 2011inline constexpr 2012bool operator>=(const month_day& __lhs, const month_day& __rhs) noexcept 2013{ return !(__lhs < __rhs); } 2014 2015 2016 2017class _LIBCPP_TYPE_VIS month_day_last { 2018private: 2019 chrono::month __m; 2020public: 2021 explicit constexpr month_day_last(const chrono::month& __val) noexcept 2022 : __m{__val} {} 2023 inline constexpr chrono::month month() const noexcept { return __m; } 2024 inline constexpr bool ok() const noexcept { return __m.ok(); } 2025}; 2026 2027inline constexpr 2028bool operator==(const month_day_last& __lhs, const month_day_last& __rhs) noexcept 2029{ return __lhs.month() == __rhs.month(); } 2030 2031inline constexpr 2032bool operator!=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept 2033{ return !(__lhs == __rhs); } 2034 2035inline constexpr 2036bool operator< (const month_day_last& __lhs, const month_day_last& __rhs) noexcept 2037{ return __lhs.month() < __rhs.month(); } 2038 2039inline constexpr 2040bool operator> (const month_day_last& __lhs, const month_day_last& __rhs) noexcept 2041{ return __rhs < __lhs; } 2042 2043inline constexpr 2044bool operator<=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept 2045{ return !(__rhs < __lhs);} 2046 2047inline constexpr 2048bool operator>=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept 2049{ return !(__lhs < __rhs); } 2050 2051inline constexpr 2052month_day_last operator/(const month& __lhs, last_spec) noexcept 2053{ return month_day_last{__lhs}; } 2054 2055inline constexpr 2056month_day_last operator/(last_spec, const month& __rhs) noexcept 2057{ return month_day_last{__rhs}; } 2058 2059inline constexpr 2060month_day_last operator/(int __lhs, last_spec) noexcept 2061{ return month_day_last{month(__lhs)}; } 2062 2063inline constexpr 2064month_day_last operator/(last_spec, int __rhs) noexcept 2065{ return month_day_last{month(__rhs)}; } 2066 2067 2068class _LIBCPP_TYPE_VIS month_weekday { 2069private: 2070 chrono::month __m; 2071 chrono::weekday_indexed __wdi; 2072public: 2073 month_weekday() = default; 2074 constexpr month_weekday(const chrono::month& __mval, const chrono::weekday_indexed& __wdival) noexcept 2075 : __m{__mval}, __wdi{__wdival} {} 2076 inline constexpr chrono::month month() const noexcept { return __m; } 2077 inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; } 2078 inline constexpr bool ok() const noexcept { return __m.ok() && __wdi.ok(); } 2079}; 2080 2081inline constexpr 2082bool operator==(const month_weekday& __lhs, const month_weekday& __rhs) noexcept 2083{ return __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); } 2084 2085inline constexpr 2086bool operator!=(const month_weekday& __lhs, const month_weekday& __rhs) noexcept 2087{ return !(__lhs == __rhs); } 2088 2089inline constexpr 2090month_weekday operator/(const month& __lhs, const weekday_indexed& __rhs) noexcept 2091{ return month_weekday{__lhs, __rhs}; } 2092 2093inline constexpr 2094month_weekday operator/(int __lhs, const weekday_indexed& __rhs) noexcept 2095{ return month_weekday{month(__lhs), __rhs}; } 2096 2097inline constexpr 2098month_weekday operator/(const weekday_indexed& __lhs, const month& __rhs) noexcept 2099{ return month_weekday{__rhs, __lhs}; } 2100 2101inline constexpr 2102month_weekday operator/(const weekday_indexed& __lhs, int __rhs) noexcept 2103{ return month_weekday{month(__rhs), __lhs}; } 2104 2105 2106class _LIBCPP_TYPE_VIS month_weekday_last { 2107 chrono::month __m; 2108 chrono::weekday_last __wdl; 2109 public: 2110 constexpr month_weekday_last(const chrono::month& __mval, const chrono::weekday_last& __wdlval) noexcept 2111 : __m{__mval}, __wdl{__wdlval} {} 2112 inline constexpr chrono::month month() const noexcept { return __m; } 2113 inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl; } 2114 inline constexpr bool ok() const noexcept { return __m.ok() && __wdl.ok(); } 2115}; 2116 2117inline constexpr 2118bool operator==(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept 2119{ return __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); } 2120 2121inline constexpr 2122bool operator!=(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept 2123{ return !(__lhs == __rhs); } 2124 2125 2126inline constexpr 2127month_weekday_last operator/(const month& __lhs, const weekday_last& __rhs) noexcept 2128{ return month_weekday_last{__lhs, __rhs}; } 2129 2130inline constexpr 2131month_weekday_last operator/(int __lhs, const weekday_last& __rhs) noexcept 2132{ return month_weekday_last{month(__lhs), __rhs}; } 2133 2134inline constexpr 2135month_weekday_last operator/(const weekday_last& __lhs, const month& __rhs) noexcept 2136{ return month_weekday_last{__rhs, __lhs}; } 2137 2138inline constexpr 2139month_weekday_last operator/(const weekday_last& __lhs, int __rhs) noexcept 2140{ return month_weekday_last{month(__rhs), __lhs}; } 2141 2142 2143class _LIBCPP_TYPE_VIS year_month { 2144 chrono::year __y; 2145 chrono::month __m; 2146public: 2147 year_month() = default; 2148 constexpr year_month(const chrono::year& __yval, const chrono::month& __mval) noexcept 2149 : __y{__yval}, __m{__mval} {} 2150 inline constexpr chrono::year year() const noexcept { return __y; } 2151 inline constexpr chrono::month month() const noexcept { return __m; } 2152 inline constexpr year_month& operator+=(const months& __dm) noexcept { this->__m += __dm; return *this; } 2153 inline constexpr year_month& operator-=(const months& __dm) noexcept { this->__m -= __dm; return *this; } 2154 inline constexpr year_month& operator+=(const years& __dy) noexcept { this->__y += __dy; return *this; } 2155 inline constexpr year_month& operator-=(const years& __dy) noexcept { this->__y -= __dy; return *this; } 2156 inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok(); } 2157}; 2158 2159inline constexpr 2160year_month operator/(const year& __y, const month& __m) noexcept { return year_month{__y, __m}; } 2161 2162inline constexpr 2163year_month operator/(const year& __y, int __m) noexcept { return year_month{__y, month(__m)}; } 2164 2165inline constexpr 2166bool operator==(const year_month& __lhs, const year_month& __rhs) noexcept 2167{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month(); } 2168 2169inline constexpr 2170bool operator!=(const year_month& __lhs, const year_month& __rhs) noexcept 2171{ return !(__lhs == __rhs); } 2172 2173inline constexpr 2174bool operator< (const year_month& __lhs, const year_month& __rhs) noexcept 2175{ return __lhs.year() != __rhs.year() ? __lhs.year() < __rhs.year() : __lhs.month() < __rhs.month(); } 2176 2177inline constexpr 2178bool operator> (const year_month& __lhs, const year_month& __rhs) noexcept 2179{ return __rhs < __lhs; } 2180 2181inline constexpr 2182bool operator<=(const year_month& __lhs, const year_month& __rhs) noexcept 2183{ return !(__rhs < __lhs);} 2184 2185inline constexpr 2186bool operator>=(const year_month& __lhs, const year_month& __rhs) noexcept 2187{ return !(__lhs < __rhs); } 2188 2189constexpr year_month operator+(const year_month& __lhs, const months& __rhs) noexcept 2190{ 2191 int __dmi = static_cast<int>(static_cast<unsigned>(__lhs.month())) - 1 + __rhs.count(); 2192 const int __dy = (__dmi >= 0 ? __dmi : __dmi-11) / 12; 2193 __dmi = __dmi - __dy * 12 + 1; 2194 return (__lhs.year() + years(__dy)) / month(static_cast<unsigned>(__dmi)); 2195} 2196 2197constexpr year_month operator+(const months& __lhs, const year_month& __rhs) noexcept 2198{ return __rhs + __lhs; } 2199 2200constexpr year_month operator+(const year_month& __lhs, const years& __rhs) noexcept 2201{ return (__lhs.year() + __rhs) / __lhs.month(); } 2202 2203constexpr year_month operator+(const years& __lhs, const year_month& __rhs) noexcept 2204{ return __rhs + __lhs; } 2205 2206constexpr months operator-(const year_month& __lhs, const year_month& __rhs) noexcept 2207{ return (__lhs.year() - __rhs.year()) + months(static_cast<unsigned>(__lhs.month()) - static_cast<unsigned>(__rhs.month())); } 2208 2209constexpr year_month operator-(const year_month& __lhs, const months& __rhs) noexcept 2210{ return __lhs + -__rhs; } 2211 2212constexpr year_month operator-(const year_month& __lhs, const years& __rhs) noexcept 2213{ return __lhs + -__rhs; } 2214 2215 2216class _LIBCPP_TYPE_VIS year_month_day { 2217private: 2218 chrono::year __y; 2219 chrono::month __m; 2220 chrono::day __d; 2221public: 2222 year_month_day() = default; 2223 inline constexpr year_month_day( 2224 const chrono::year& __yval, const chrono::month& __mval, const chrono::day& __dval) noexcept 2225 : __y{__yval}, __m{__mval}, __d{__dval} {} 2226// inline constexpr year_month_day(const year_month_day_last& __ymdl) noexcept; 2227// inline constexpr year_month_day(const sys_days& dp) noexcept; 2228// inline explicit constexpr year_month_day(const local_days& dp) noexcept; 2229 constexpr year_month_day& operator+=(const months& __dm) noexcept; 2230 constexpr year_month_day& operator-=(const months& __dm) noexcept; 2231 constexpr year_month_day& operator+=(const years& __dy) noexcept; 2232 constexpr year_month_day& operator-=(const years& __dy) noexcept; 2233 inline constexpr chrono::year year() const noexcept { return __y; } 2234 inline constexpr chrono::month month() const noexcept { return __m; } 2235 inline constexpr chrono::day day() const noexcept { return __d; } 2236// inline constexpr operator sys_days() const noexcept; 2237// inline explicit constexpr operator local_days() const noexcept; 2238 2239// TODO: This is not quite correct; requires the calendar bits to do right 2240// d_ is in the range [1d, (y_/m_/last).day()], 2241 inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok() && __d.ok(); } 2242}; 2243 2244inline constexpr 2245bool operator==(const year_month_day& __lhs, const year_month_day& __rhs) noexcept 2246{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); } 2247 2248inline constexpr 2249bool operator!=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept 2250{ return !(__lhs == __rhs); } 2251 2252inline constexpr 2253bool operator< (const year_month_day& __lhs, const year_month_day& __rhs) noexcept 2254{ 2255 if (__lhs.year() < __rhs.year()) return true; 2256 if (__lhs.year() > __rhs.year()) return false; 2257 if (__lhs.month() < __rhs.month()) return true; 2258 if (__lhs.month() > __rhs.month()) return false; 2259 return __lhs.day() < __rhs.day(); 2260} 2261 2262inline constexpr 2263bool operator> (const year_month_day& __lhs, const year_month_day& __rhs) noexcept 2264{ return __rhs < __lhs; } 2265 2266inline constexpr 2267bool operator<=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept 2268{ return !(__rhs < __lhs);} 2269 2270inline constexpr 2271bool operator>=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept 2272{ return !(__lhs < __rhs); } 2273 2274inline constexpr 2275year_month_day operator/(const year_month& __lhs, const day& __rhs) noexcept 2276{ return year_month_day{__lhs.year(), __lhs.month(), __rhs}; } 2277 2278inline constexpr 2279year_month_day operator/(const year_month& __lhs, int __rhs) noexcept 2280{ return __lhs / day(__rhs); } 2281 2282inline constexpr 2283year_month_day operator/(const year& __lhs, const month_day& __rhs) noexcept 2284{ return __lhs / __rhs.month() / __rhs.day(); } 2285 2286inline constexpr 2287year_month_day operator/(int __lhs, const month_day& __rhs) noexcept 2288{ return year(__lhs) / __rhs; } 2289 2290inline constexpr 2291year_month_day operator/(const month_day& __lhs, const year& __rhs) noexcept 2292{ return __rhs / __lhs; } 2293 2294inline constexpr 2295year_month_day operator/(const month_day& __lhs, int __rhs) noexcept 2296{ return year(__rhs) / __lhs; } 2297 2298 2299inline constexpr 2300year_month_day operator+(const year_month_day& __lhs, const months& __rhs) noexcept 2301{ return (__lhs.year()/__lhs.month() + __rhs)/__lhs.day(); } 2302 2303inline constexpr 2304year_month_day operator+(const months& __lhs, const year_month_day& __rhs) noexcept 2305{ return __rhs + __lhs; } 2306 2307inline constexpr 2308year_month_day operator-(const year_month_day& __lhs, const months& __rhs) noexcept 2309{ return __lhs + -__rhs; } 2310 2311inline constexpr 2312year_month_day operator+(const year_month_day& __lhs, const years& __rhs) noexcept 2313{ return (__lhs.year() + __rhs) / __lhs.month() / __lhs.day(); } 2314 2315inline constexpr 2316year_month_day operator+(const years& __lhs, const year_month_day& __rhs) noexcept 2317{ return __rhs + __lhs; } 2318 2319inline constexpr 2320year_month_day operator-(const year_month_day& __lhs, const years& __rhs) noexcept 2321{ return __lhs + -__rhs; } 2322 2323inline constexpr year_month_day& year_month_day::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; } 2324inline constexpr year_month_day& year_month_day::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; } 2325inline constexpr year_month_day& year_month_day::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; } 2326inline constexpr year_month_day& year_month_day::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; } 2327 2328class _LIBCPP_TYPE_VIS year_month_day_last { 2329private: 2330 chrono::year __y; 2331 chrono::month_day_last __mdl; 2332public: 2333 constexpr year_month_day_last(const year& __yval, const month_day_last& __mdlval) noexcept 2334 : __y{__yval}, __mdl{__mdlval} {} 2335 2336 constexpr year_month_day_last& operator+=(const months& __m) noexcept; 2337 constexpr year_month_day_last& operator-=(const months& __m) noexcept; 2338 constexpr year_month_day_last& operator+=(const years& __y) noexcept; 2339 constexpr year_month_day_last& operator-=(const years& __y) noexcept; 2340 2341 constexpr chrono::year year() const noexcept { return __y; } 2342 constexpr chrono::month month() const noexcept { return __mdl.month(); } 2343 constexpr chrono::month_day_last month_day_last() const noexcept { return __mdl; } 2344// constexpr chrono::day day() const noexcept; 2345// constexpr operator sys_days() const noexcept; 2346// explicit constexpr operator local_days() const noexcept; 2347 constexpr bool ok() const noexcept { return __y.ok() && __mdl.ok(); } 2348}; 2349 2350inline constexpr 2351bool operator==(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept 2352{ return __lhs.year() == __rhs.year() && __lhs.month_day_last() == __rhs.month_day_last(); } 2353 2354inline constexpr 2355bool operator!=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept 2356{ return !(__lhs == __rhs); } 2357 2358inline constexpr 2359bool operator< (const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept 2360{ 2361 if (__lhs.year() < __rhs.year()) return true; 2362 if (__lhs.year() > __rhs.year()) return false; 2363 return __lhs.month_day_last() < __rhs.month_day_last(); 2364} 2365 2366inline constexpr 2367bool operator> (const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept 2368{ return __rhs < __lhs; } 2369 2370inline constexpr 2371bool operator<=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept 2372{ return !(__rhs < __lhs);} 2373 2374inline constexpr 2375bool operator>=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept 2376{ return !(__lhs < __rhs); } 2377 2378inline constexpr year_month_day_last operator/(const year_month& __lhs, last_spec) noexcept 2379{ return year_month_day_last{__lhs.year(), month_day_last{__lhs.month()}}; } 2380 2381inline constexpr year_month_day_last operator/(const year& __lhs, const month_day_last& __rhs) noexcept 2382{ return year_month_day_last{__lhs, __rhs}; } 2383 2384inline constexpr year_month_day_last operator/(int __lhs, const month_day_last& __rhs) noexcept 2385{ return year_month_day_last{year{__lhs}, __rhs}; } 2386 2387inline constexpr year_month_day_last operator/(const month_day_last& __lhs, const year& __rhs) noexcept 2388{ return __rhs / __lhs; } 2389 2390inline constexpr year_month_day_last operator/(const month_day_last& __lhs, int __rhs) noexcept 2391{ return year{__rhs} / __lhs; } 2392 2393 2394inline constexpr 2395year_month_day_last operator+(const year_month_day_last& __lhs, const months& __rhs) noexcept 2396{ return (__lhs.year() / __lhs.month() + __rhs) / last; } 2397 2398inline constexpr 2399year_month_day_last operator+(const months& __lhs, const year_month_day_last& __rhs) noexcept 2400{ return __rhs + __lhs; } 2401 2402inline constexpr 2403year_month_day_last operator-(const year_month_day_last& __lhs, const months& __rhs) noexcept 2404{ return __lhs + (-__rhs); } 2405 2406inline constexpr 2407year_month_day_last operator+(const year_month_day_last& __lhs, const years& __rhs) noexcept 2408{ return year_month_day_last{__lhs.year() + __rhs, __lhs.month_day_last()}; } 2409 2410inline constexpr 2411year_month_day_last operator+(const years& __lhs, const year_month_day_last& __rhs) noexcept 2412{ return __rhs + __lhs; } 2413 2414inline constexpr 2415year_month_day_last operator-(const year_month_day_last& __lhs, const years& __rhs) noexcept 2416{ return __lhs + (-__rhs); } 2417 2418inline constexpr year_month_day_last& year_month_day_last::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; } 2419inline constexpr year_month_day_last& year_month_day_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; } 2420inline constexpr year_month_day_last& year_month_day_last::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; } 2421inline constexpr year_month_day_last& year_month_day_last::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; } 2422 2423class _LIBCPP_TYPE_VIS year_month_weekday { 2424 chrono::year __y; 2425 chrono::month __m; 2426 chrono::weekday_indexed __wdi; 2427public: 2428 year_month_weekday() = default; 2429 constexpr year_month_weekday(const chrono::year& __yval, const chrono::month& __mval, 2430 const chrono::weekday_indexed& __wdival) noexcept 2431 : __y{__yval}, __m{__mval}, __wdi{__wdival} {} 2432// constexpr year_month_weekday(const sys_days& dp) noexcept; 2433// explicit constexpr year_month_weekday(const local_days& dp) noexcept; 2434 constexpr year_month_weekday& operator+=(const months& m) noexcept; 2435 constexpr year_month_weekday& operator-=(const months& m) noexcept; 2436 constexpr year_month_weekday& operator+=(const years& y) noexcept; 2437 constexpr year_month_weekday& operator-=(const years& y) noexcept; 2438 2439 inline constexpr chrono::year year() const noexcept { return __y; } 2440 inline constexpr chrono::month month() const noexcept { return __m; } 2441 inline constexpr chrono::weekday weekday() const noexcept { return __wdi.weekday(); } 2442 inline constexpr unsigned index() const noexcept { return __wdi.index(); } 2443 inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; } 2444 2445// constexpr operator sys_days() const noexcept; 2446// explicit constexpr operator local_days() const noexcept; 2447 inline constexpr bool ok() const noexcept 2448 { 2449 if (!__y.ok() || !__m.ok() || !__wdi.ok()) return false; 2450 // TODO: make sure it's a valid date 2451 return true; 2452 } 2453}; 2454 2455inline constexpr 2456bool operator==(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept 2457{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); } 2458 2459inline constexpr 2460bool operator!=(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept 2461{ return !(__lhs == __rhs); } 2462 2463inline constexpr 2464year_month_weekday operator/(const year_month& __lhs, const weekday_indexed& __rhs) noexcept 2465{ return year_month_weekday{__lhs.year(), __lhs.month(), __rhs}; } 2466 2467inline constexpr 2468year_month_weekday operator/(const year& __lhs, const month_weekday& __rhs) noexcept 2469{ return year_month_weekday{__lhs, __rhs.month(), __rhs.weekday_indexed()}; } 2470 2471inline constexpr 2472year_month_weekday operator/(int __lhs, const month_weekday& __rhs) noexcept 2473{ return year(__lhs) / __rhs; } 2474 2475inline constexpr 2476year_month_weekday operator/(const month_weekday& __lhs, const year& __rhs) noexcept 2477{ return __rhs / __lhs; } 2478 2479inline constexpr 2480year_month_weekday operator/(const month_weekday& __lhs, int __rhs) noexcept 2481{ return year(__rhs) / __lhs; } 2482 2483 2484inline constexpr 2485year_month_weekday operator+(const year_month_weekday& __lhs, const months& __rhs) noexcept 2486{ return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_indexed(); } 2487 2488inline constexpr 2489year_month_weekday operator+(const months& __lhs, const year_month_weekday& __rhs) noexcept 2490{ return __rhs + __lhs; } 2491 2492inline constexpr 2493year_month_weekday operator-(const year_month_weekday& __lhs, const months& __rhs) noexcept 2494{ return __lhs + (-__rhs); } 2495 2496inline constexpr 2497year_month_weekday operator+(const year_month_weekday& __lhs, const years& __rhs) noexcept 2498{ return year_month_weekday{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_indexed()}; } 2499 2500inline constexpr 2501year_month_weekday operator+(const years& __lhs, const year_month_weekday& __rhs) noexcept 2502{ return __rhs + __lhs; } 2503 2504inline constexpr 2505year_month_weekday operator-(const year_month_weekday& __lhs, const years& __rhs) noexcept 2506{ return __lhs + (-__rhs); } 2507 2508 2509inline constexpr year_month_weekday& year_month_weekday::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; } 2510inline constexpr year_month_weekday& year_month_weekday::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; } 2511inline constexpr year_month_weekday& year_month_weekday::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; } 2512inline constexpr year_month_weekday& year_month_weekday::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; } 2513 2514class _LIBCPP_TYPE_VIS year_month_weekday_last { 2515private: 2516 chrono::year __y; 2517 chrono::month __m; 2518 chrono::weekday_last __wdl; 2519public: 2520 constexpr year_month_weekday_last(const chrono::year& __yval, const chrono::month& __mval, 2521 const chrono::weekday_last& __wdlval) noexcept 2522 : __y{__yval}, __m{__mval}, __wdl{__wdlval} {} 2523 constexpr year_month_weekday_last& operator+=(const months& __dm) noexcept; 2524 constexpr year_month_weekday_last& operator-=(const months& __dm) noexcept; 2525 constexpr year_month_weekday_last& operator+=(const years& __dy) noexcept; 2526 constexpr year_month_weekday_last& operator-=(const years& __dy) noexcept; 2527 2528 inline constexpr chrono::year year() const noexcept { return __y; } 2529 inline constexpr chrono::month month() const noexcept { return __m; } 2530 inline constexpr chrono::weekday weekday() const noexcept { return __wdl.weekday(); } 2531 inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl; } 2532// constexpr operator sys_days() const noexcept; 2533// explicit constexpr operator local_days() const noexcept; 2534 inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok() && __wdl.ok(); } 2535}; 2536 2537inline constexpr 2538bool operator==(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept 2539{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); } 2540 2541inline constexpr 2542bool operator!=(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept 2543{ return !(__lhs == __rhs); } 2544 2545 2546inline constexpr 2547year_month_weekday_last operator/(const year_month& __lhs, const weekday_last& __rhs) noexcept 2548{ return year_month_weekday_last{__lhs.year(), __lhs.month(), __rhs}; } 2549 2550inline constexpr 2551year_month_weekday_last operator/(const year& __lhs, const month_weekday_last& __rhs) noexcept 2552{ return year_month_weekday_last{__lhs, __rhs.month(), __rhs.weekday_last()}; } 2553 2554inline constexpr 2555year_month_weekday_last operator/(int __lhs, const month_weekday_last& __rhs) noexcept 2556{ return year(__lhs) / __rhs; } 2557 2558inline constexpr 2559year_month_weekday_last operator/(const month_weekday_last& __lhs, const year& __rhs) noexcept 2560{ return __rhs / __lhs; } 2561 2562inline constexpr 2563year_month_weekday_last operator/(const month_weekday_last& __lhs, int __rhs) noexcept 2564{ return year(__rhs) / __lhs; } 2565 2566 2567inline constexpr 2568year_month_weekday_last operator+(const year_month_weekday_last& __lhs, const months& __rhs) noexcept 2569{ return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_last(); } 2570 2571inline constexpr 2572year_month_weekday_last operator+(const months& __lhs, const year_month_weekday_last& __rhs) noexcept 2573{ return __rhs + __lhs; } 2574 2575inline constexpr 2576year_month_weekday_last operator-(const year_month_weekday_last& __lhs, const months& __rhs) noexcept 2577{ return __lhs + (-__rhs); } 2578 2579inline constexpr 2580year_month_weekday_last operator+(const year_month_weekday_last& __lhs, const years& __rhs) noexcept 2581{ return year_month_weekday_last{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_last()}; } 2582 2583inline constexpr 2584year_month_weekday_last operator+(const years& __lhs, const year_month_weekday_last& __rhs) noexcept 2585{ return __rhs + __lhs; } 2586 2587inline constexpr 2588year_month_weekday_last operator-(const year_month_weekday_last& __lhs, const years& __rhs) noexcept 2589{ return __lhs + (-__rhs); } 2590 2591inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; } 2592inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; } 2593inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; } 2594inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; } 2595 2596#endif // _LIBCPP_STD_VER > 17 2597} // chrono 2598 2599#if _LIBCPP_STD_VER > 11 2600// Suffixes for duration literals [time.duration.literals] 2601inline namespace literals 2602{ 2603 inline namespace chrono_literals 2604 { 2605 2606 constexpr chrono::hours operator""h(unsigned long long __h) 2607 { 2608 return chrono::hours(static_cast<chrono::hours::rep>(__h)); 2609 } 2610 2611 constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h) 2612 { 2613 return chrono::duration<long double, ratio<3600,1>>(__h); 2614 } 2615 2616 2617 constexpr chrono::minutes operator""min(unsigned long long __m) 2618 { 2619 return chrono::minutes(static_cast<chrono::minutes::rep>(__m)); 2620 } 2621 2622 constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m) 2623 { 2624 return chrono::duration<long double, ratio<60,1>> (__m); 2625 } 2626 2627 2628 constexpr chrono::seconds operator""s(unsigned long long __s) 2629 { 2630 return chrono::seconds(static_cast<chrono::seconds::rep>(__s)); 2631 } 2632 2633 constexpr chrono::duration<long double> operator""s(long double __s) 2634 { 2635 return chrono::duration<long double> (__s); 2636 } 2637 2638 2639 constexpr chrono::milliseconds operator""ms(unsigned long long __ms) 2640 { 2641 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms)); 2642 } 2643 2644 constexpr chrono::duration<long double, milli> operator""ms(long double __ms) 2645 { 2646 return chrono::duration<long double, milli>(__ms); 2647 } 2648 2649 2650 constexpr chrono::microseconds operator""us(unsigned long long __us) 2651 { 2652 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us)); 2653 } 2654 2655 constexpr chrono::duration<long double, micro> operator""us(long double __us) 2656 { 2657 return chrono::duration<long double, micro> (__us); 2658 } 2659 2660 2661 constexpr chrono::nanoseconds operator""ns(unsigned long long __ns) 2662 { 2663 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns)); 2664 } 2665 2666 constexpr chrono::duration<long double, nano> operator""ns(long double __ns) 2667 { 2668 return chrono::duration<long double, nano> (__ns); 2669 } 2670 2671#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS) 2672 constexpr chrono::day operator ""d(unsigned long long __d) noexcept 2673 { 2674 return chrono::day(static_cast<unsigned>(__d)); 2675 } 2676 2677 constexpr chrono::year operator ""y(unsigned long long __y) noexcept 2678 { 2679 return chrono::year(static_cast<int>(__y)); 2680 } 2681#endif 2682}} 2683 2684namespace chrono { // hoist the literals into namespace std::chrono 2685 using namespace literals::chrono_literals; 2686} 2687 2688#endif 2689 2690_LIBCPP_END_NAMESPACE_STD 2691 2692_LIBCPP_POP_MACROS 2693 2694#endif // _LIBCPP_CHRONO 2695