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