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