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