libcxx/include/chrono

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   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 // clang-format off
  14
  15 /*
  16     chrono synopsis
  17
  18 #include <compare> // C++20
  19
  20 namespace std
  21 {
  22 namespace chrono
  23 {
  24
  25 template <class ToDuration, class Rep, class Period>
  26 constexpr
  27 ToDuration
  28 duration_cast(const duration<Rep, Period>& fd);
  29
  30 template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
  31
  32 template <class Rep> inline constexpr bool treat_as_floating_point_v
  33     = treat_as_floating_point<Rep>::value;                       // C++17
  34
  35 template <class Rep>
  36 struct duration_values
  37 {
  38 public:
  39     static constexpr Rep zero(); // noexcept in C++20
  40     static constexpr Rep max();  // noexcept in C++20
  41     static constexpr Rep min();  // noexcept in C++20
  42 };
  43
  44 // duration
  45
  46 template <class Rep, class Period = ratio<1>>
  47 class duration
  48 {
  49     static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
  50     static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
  51     static_assert(Period::num > 0, "duration period must be positive");
  52 public:
  53     typedef Rep rep;
  54     typedef typename _Period::type period;
  55
  56     constexpr duration() = default;
  57     template <class Rep2>
  58         constexpr explicit duration(const Rep2& r,
  59             typename enable_if
  60             <
  61                is_convertible<const Rep2&, rep>::value &&
  62                (treat_as_floating_point<rep>::value ||
  63                !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
  64             >::type* = 0);
  65
  66     // conversions
  67     template <class Rep2, class Period2>
  68         constexpr duration(const duration<Rep2, Period2>& d,
  69             typename enable_if
  70             <
  71                 treat_as_floating_point<rep>::value ||
  72                 ratio_divide<Period2, period>::type::den == 1
  73             >::type* = 0);
  74
  75     // observer
  76
  77     constexpr rep count() const;
  78
  79     // arithmetic
  80
  81     constexpr common_type<duration>::type  operator+() const;
  82     constexpr common_type<duration>::type  operator-() const;
  83     constexpr duration& operator++();    // constexpr in C++17
  84     constexpr duration  operator++(int); // constexpr in C++17
  85     constexpr duration& operator--();    // constexpr in C++17
  86     constexpr duration  operator--(int); // constexpr in C++17
  87
  88     constexpr duration& operator+=(const duration& d);  // constexpr in C++17
  89     constexpr duration& operator-=(const duration& d);  // constexpr in C++17
  90
  91     duration& operator*=(const rep& rhs);       // constexpr in C++17
  92     duration& operator/=(const rep& rhs);       // constexpr in C++17
  93     duration& operator%=(const rep& rhs);       // constexpr in C++17
  94     duration& operator%=(const duration& rhs);  // constexpr in C++17
  95
  96     // special values
  97
  98     static constexpr duration zero(); // noexcept in C++20
  99     static constexpr duration min();  // noexcept in C++20
 100     static constexpr duration max();  // noexcept in C++20
 101 };
 102
 103 typedef duration<long long,         nano> nanoseconds;
 104 typedef duration<long long,        micro> microseconds;
 105 typedef duration<long long,        milli> milliseconds;
 106 typedef duration<long long              > seconds;
 107 typedef duration<     long, ratio<  60> > minutes;
 108 typedef duration<     long, ratio<3600> > hours;
 109
 110 template <class Clock, class Duration = typename Clock::duration>
 111 class time_point
 112 {
 113 public:
 114     typedef Clock                     clock;
 115     typedef Duration                  duration;
 116     typedef typename duration::rep    rep;
 117     typedef typename duration::period period;
 118 private:
 119     duration d_;  // exposition only
 120
 121 public:
 122     time_point();  // has value "epoch" // constexpr in C++14
 123     explicit time_point(const duration& d);  // same as time_point() + d // constexpr in C++14
 124
 125     // conversions
 126     template <class Duration2>
 127        time_point(const time_point<clock, Duration2>& t); // constexpr in C++14
 128
 129     // observer
 130
 131     duration time_since_epoch() const; // constexpr in C++14
 132
 133     // arithmetic
 134
 135     time_point& operator+=(const duration& d); // constexpr in C++17
 136     time_point& operator-=(const duration& d); // constexpr in C++17
 137
 138     // special values
 139
 140     static constexpr time_point min();  // noexcept in C++20
 141     static constexpr time_point max();  // noexcept in C++20
 142 };
 143
 144 } // chrono
 145
 146 // common_type traits
 147 template <class Rep1, class Period1, class Rep2, class Period2>
 148   struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
 149
 150 template <class Clock, class Duration1, class Duration2>
 151   struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
 152
 153 namespace chrono {
 154
 155 // duration arithmetic
 156 template <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);
 160 template <class Rep1, class Period1, class Rep2, class Period2>
 161   constexpr
 162   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
 163   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 164 template <class Rep1, class Period, class Rep2>
 165   constexpr
 166   duration<typename common_type<Rep1, Rep2>::type, Period>
 167   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 168 template <class Rep1, class Period, class Rep2>
 169   constexpr
 170   duration<typename common_type<Rep1, Rep2>::type, Period>
 171   operator*(const Rep1& s, const duration<Rep2, Period>& d);
 172 template <class Rep1, class Period, class Rep2>
 173   constexpr
 174   duration<typename common_type<Rep1, Rep2>::type, Period>
 175   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 176 template <class Rep1, class Period1, class Rep2, class Period2>
 177   constexpr
 178   typename common_type<Rep1, Rep2>::type
 179   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 180
 181 // duration comparisons
 182 template <class Rep1, class Period1, class Rep2, class Period2>
 183    constexpr
 184    bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 185 template <class Rep1, class Period1, class Rep2, class Period2>
 186    constexpr
 187    bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); // removed in C++20
 188 template <class Rep1, class Period1, class Rep2, class Period2>
 189    constexpr
 190    bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 191 template <class Rep1, class Period1, class Rep2, class Period2>
 192    constexpr
 193    bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 194 template <class Rep1, class Period1, class Rep2, class Period2>
 195    constexpr
 196    bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 197 template <class Rep1, class Period1, class Rep2, class Period2>
 198    constexpr
 199    bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 200 template<class Rep1, class Period1, class Rep2, class Period2>
 201   requires three_way_comparable<typename CT::rep>
 202   constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
 203                              const duration<Rep2, Period2>& rhs);                           // since C++20
 204
 205 // duration_cast
 206 template <class ToDuration, class Rep, class Period>
 207   ToDuration duration_cast(const duration<Rep, Period>& d);
 208
 209 template <class ToDuration, class Rep, class Period>
 210     constexpr ToDuration floor(const duration<Rep, Period>& d);    // C++17
 211 template <class ToDuration, class Rep, class Period>
 212     constexpr ToDuration ceil(const duration<Rep, Period>& d);     // C++17
 213 template <class ToDuration, class Rep, class Period>
 214     constexpr ToDuration round(const duration<Rep, Period>& d);    // C++17
 215
 216 // duration I/O
 217 template<class charT, class traits, class Rep, class Period>       // C++20
 218   basic_ostream<charT, traits>&
 219     operator<<(basic_ostream<charT, traits>& os,
 220                const duration<Rep, Period>& d);
 221
 222 // time_point arithmetic (all constexpr in C++14)
 223 template <class Clock, class Duration1, class Rep2, class Period2>
 224   time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
 225   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 226 template <class Rep1, class Period1, class Clock, class Duration2>
 227   time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
 228   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 229 template <class Clock, class Duration1, class Rep2, class Period2>
 230   time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
 231   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 232 template <class Clock, class Duration1, class Duration2>
 233   typename common_type<Duration1, Duration2>::type
 234   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 235
 236 // time_point comparisons (all constexpr in C++14)
 237 template <class Clock, class Duration1, class Duration2>
 238    bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 239 template <class Clock, class Duration1, class Duration2>
 240    bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // removed in C++20
 241 template <class Clock, class Duration1, class Duration2>
 242    bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 243 template <class Clock, class Duration1, class Duration2>
 244    bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 245 template <class Clock, class Duration1, class Duration2>
 246    bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 247 template <class Clock, class Duration1, class Duration2>
 248    bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 249 template<class Clock, class Duration1,
 250          three_way_comparable_with<Duration1> Duration2>
 251   constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
 252                              const time_point<Clock, Duration2>& rhs);                                // since C++20
 253
 254 // time_point_cast (constexpr in C++14)
 255
 256 template <class ToDuration, class Clock, class Duration>
 257   time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
 258
 259 template <class ToDuration, class Clock, class Duration>
 260     constexpr time_point<Clock, ToDuration>
 261     floor(const time_point<Clock, Duration>& tp);                  // C++17
 262
 263 template <class ToDuration, class Clock, class Duration>
 264     constexpr time_point<Clock, ToDuration>
 265     ceil(const time_point<Clock, Duration>& tp);                   // C++17
 266
 267 template <class ToDuration, class Clock, class Duration>
 268     constexpr time_point<Clock, ToDuration>
 269     round(const time_point<Clock, Duration>& tp);                  // C++17
 270
 271 template <class Rep, class Period>
 272     constexpr duration<Rep, Period> abs(duration<Rep, Period> d);  // C++17
 273
 274 // Clocks
 275
 276 class system_clock
 277 {
 278 public:
 279     typedef microseconds                     duration;
 280     typedef duration::rep                    rep;
 281     typedef duration::period                 period;
 282     typedef chrono::time_point<system_clock> time_point;
 283     static const bool is_steady =            false; // constexpr in C++14
 284
 285     static time_point now() noexcept;
 286     static time_t     to_time_t  (const time_point& __t) noexcept;
 287     static time_point from_time_t(time_t __t) noexcept;
 288 };
 289
 290 template <class Duration>
 291   using sys_time  = time_point<system_clock, Duration>; // C++20
 292 using sys_seconds = sys_time<seconds>;                  // C++20
 293 using sys_days    = sys_time<days>;                     // C++20
 294
 295 template<class charT, class traits, class Duration>     // C++20
 296   basic_ostream<charT, traits>&
 297     operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);
 298
 299 template<class charT, class traits>                    // C++20
 300   basic_ostream<charT, traits>&
 301     operator<<(basic_ostream<charT, traits>& os, const sys_days& dp);
 302
 303 // [time.clock.utc], class utc_clock
 304 class utc_clock {                                      // C++20
 305 public:
 306     using rep                       = a signed arithmetic type;
 307     using period                    = ratio<unspecified, unspecified>;
 308     using duration                  = chrono::duration<rep, period>;
 309     using time_point                = chrono::time_point<utc_clock>;
 310     static constexpr bool is_steady = unspecified;
 311
 312     static time_point now();
 313
 314     template<class Duration>
 315       static sys_time<common_type_t<Duration, seconds>>
 316         to_sys(const utc_time<Duration>& t);
 317     template<class Duration>
 318       static utc_time<common_type_t<Duration, seconds>>
 319         from_sys(const sys_time<Duration>& t);
 320 };
 321
 322 template<class Duration>
 323 using utc_time  = time_point<utc_clock, Duration>;      // C++20
 324 using utc_seconds = utc_time<seconds>;                  // C++20
 325
 326 template<class charT, class traits, class Duration>     // C++20
 327   basic_ostream<charT, traits>&
 328     operator<<(basic_ostream<charT, traits>& os, const utc_time<Duration>& t);
 329
 330 struct leap_second_info {                               // C++20
 331   bool    is_leap_second;
 332   seconds elapsed;
 333 };
 334
 335 template<class Duration>                                // C++20
 336   leap_second_info get_leap_second_info(const utc_time<Duration>& ut);
 337
 338 class file_clock                                        // C++20
 339 {
 340 public:
 341     typedef see-below                      rep;
 342     typedef nano                           period;
 343     typedef chrono::duration<rep, period>  duration;
 344     typedef chrono::time_point<file_clock> time_point;
 345     static constexpr bool is_steady =      false;
 346
 347     static time_point now() noexcept;
 348
 349     template<class Duration>
 350     static sys_time<see-below> to_sys(const file_time<Duration>&);
 351
 352     template<class Duration>
 353     static file_time<see-below> from_sys(const sys_time<Duration>&);
 354 };
 355
 356 template<class Duration>
 357   using file_time = time_point<file_clock, Duration>;   // C++20
 358
 359 template<class charT, class traits, class Duration>     // C++20
 360   basic_ostream<charT, traits>&
 361     operator<<(basic_ostream<charT, traits>& os, const file_time<Duration>& tp);
 362
 363 class steady_clock
 364 {
 365 public:
 366     typedef nanoseconds                                   duration;
 367     typedef duration::rep                                 rep;
 368     typedef duration::period                              period;
 369     typedef chrono::time_point<steady_clock, duration>    time_point;
 370     static const bool is_steady =                         true; // constexpr in C++14
 371
 372     static time_point now() noexcept;
 373 };
 374
 375 typedef steady_clock high_resolution_clock;
 376
 377 // 25.7.8, local time           // C++20
 378 struct local_t {};
 379 template<class Duration>
 380   using local_time  = time_point<local_t, Duration>;
 381 using local_seconds = local_time<seconds>;
 382 using local_days    = local_time<days>;
 383
 384 template<class charT, class traits, class Duration>     // C++20
 385   basic_ostream<charT, traits>&
 386     operator<<(basic_ostream<charT, traits>& os, const local_time<Duration>& tp);
 387
 388 // 25.8.2, class last_spec    // C++20
 389 struct last_spec;
 390
 391 // 25.8.3, class day          // C++20
 392
 393 class day;
 394 constexpr bool operator==(const day& x, const day& y) noexcept;
 395 constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
 396 constexpr day  operator+(const day&  x, const days& y) noexcept;
 397 constexpr day  operator+(const days& x, const day&  y) noexcept;
 398 constexpr day  operator-(const day&  x, const days& y) noexcept;
 399 constexpr days operator-(const day&  x, const day&  y) noexcept;
 400 template<class charT, class traits>
 401   basic_ostream<charT, traits>&
 402     operator<<(basic_ostream<charT, traits>& os, const day& d);
 403
 404 // 25.8.4, class month    // C++20
 405 class month;
 406 constexpr bool operator==(const month& x, const month& y) noexcept;
 407 constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
 408
 409 constexpr month  operator+(const month&  x, const months& y) noexcept;
 410 constexpr month  operator+(const months& x,  const month& y) noexcept;
 411 constexpr month  operator-(const month&  x, const months& y) noexcept;
 412 constexpr months operator-(const month&  x,  const month& y) noexcept;
 413 template<class charT, class traits>
 414   basic_ostream<charT, traits>&
 415     operator<<(basic_ostream<charT, traits>& os, const month& m);
 416
 417 // 25.8.5, class year    // C++20
 418 class year;
 419 constexpr bool operator==(const year& x, const year& y) noexcept;
 420 constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
 421
 422 constexpr year  operator+(const year&  x, const years& y) noexcept;
 423 constexpr year  operator+(const years& x, const year&  y) noexcept;
 424 constexpr year  operator-(const year&  x, const years& y) noexcept;
 425 constexpr years operator-(const year&  x, const year&  y) noexcept;
 426 template<class charT, class traits>
 427   basic_ostream<charT, traits>&
 428     operator<<(basic_ostream<charT, traits>& os, const year& y);
 429
 430 // 25.8.6, class weekday    // C++20
 431 class weekday;
 432
 433 constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
 434 constexpr weekday operator+(const weekday& x, const days&    y) noexcept;
 435 constexpr weekday operator+(const days&    x, const weekday& y) noexcept;
 436 constexpr weekday operator-(const weekday& x, const days&    y) noexcept;
 437 constexpr days    operator-(const weekday& x, const weekday& y) noexcept;
 438 template<class charT, class traits>
 439   basic_ostream<charT, traits>&
 440     operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
 441
 442 // 25.8.7, class weekday_indexed    // C++20
 443
 444 class weekday_indexed;
 445 constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 446
 447 template<class charT, class traits>
 448   basic_ostream<charT, traits>&
 449     operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
 450
 451 // 25.8.8, class weekday_last    // C++20
 452 class weekday_last;
 453
 454 constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
 455
 456 template<class charT, class traits>
 457   basic_ostream<charT, traits>&
 458     operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
 459
 460 // 25.8.9, class month_day    // C++20
 461 class month_day;
 462
 463 constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
 464 constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
 465
 466 template<class charT, class traits>
 467   basic_ostream<charT, traits>&
 468     operator<<(basic_ostream<charT, traits>& os, const month_day& md);
 469
 470 // 25.8.10, class month_day_last    // C++20
 471 class month_day_last;
 472
 473 constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
 474 constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
 475
 476 template<class charT, class traits>
 477   basic_ostream<charT, traits>&
 478     operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
 479
 480 // 25.8.11, class month_weekday    // C++20
 481 class month_weekday;
 482
 483 constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
 484
 485 template<class charT, class traits>
 486   basic_ostream<charT, traits>&
 487     operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
 488
 489 // 25.8.12, class month_weekday_last    // C++20
 490 class month_weekday_last;
 491
 492 constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
 493
 494 template<class charT, class traits>
 495   basic_ostream<charT, traits>&
 496     operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mwdl);
 497
 498
 499 // 25.8.13, class year_month    // C++20
 500 class year_month;
 501
 502 constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
 503 constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
 504
 505 constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
 506 constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
 507 constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
 508 constexpr months operator-(const year_month& x, const year_month& y) noexcept;
 509 constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
 510 constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
 511 constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
 512
 513 template<class charT, class traits>
 514   basic_ostream<charT, traits>&
 515     operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
 516
 517 // 25.8.14, class year_month_day class    // C++20
 518 year_month_day;
 519
 520 constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
 521 constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
 522
 523 constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
 524 constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
 525 constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
 526 constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
 527 constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
 528 constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
 529
 530 template<class charT, class traits>
 531   basic_ostream<charT, traits>&
 532     operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
 533
 534 // 25.8.15, class year_month_day_last    // C++20
 535 class year_month_day_last;
 536
 537 constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
 538 constexpr strong_ordering operator<=>(const year_month_day_last_day& x, const year_month_day_last_day& y) noexcept;
 539
 540 constexpr year_month_day_last
 541   operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
 542 constexpr year_month_day_last
 543   operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
 544 constexpr year_month_day_last
 545   operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
 546 constexpr year_month_day_last
 547   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
 548 constexpr year_month_day_last
 549   operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
 550 constexpr year_month_day_last
 551   operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
 552
 553 template<class charT, class traits>
 554   basic_ostream<charT, traits>&
 555     operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
 556
 557 // 25.8.16, class year_month_weekday    // C++20
 558 class year_month_weekday;
 559
 560 constexpr bool operator==(const year_month_weekday& x,
 561                           const year_month_weekday& y) noexcept;
 562
 563 constexpr year_month_weekday
 564   operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
 565 constexpr year_month_weekday
 566   operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
 567 constexpr year_month_weekday
 568   operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
 569 constexpr year_month_weekday
 570   operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
 571 constexpr year_month_weekday
 572   operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
 573 constexpr year_month_weekday
 574   operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
 575
 576 template<class charT, class traits>
 577   basic_ostream<charT, traits>&
 578     operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
 579
 580 // 25.8.17, class year_month_weekday_last    // C++20
 581 class year_month_weekday_last;
 582
 583 constexpr bool operator==(const year_month_weekday_last& x,
 584                           const year_month_weekday_last& y) noexcept;
 585 constexpr year_month_weekday_last
 586   operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
 587 constexpr year_month_weekday_last
 588   operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
 589 constexpr year_month_weekday_last
 590   operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
 591 constexpr year_month_weekday_last
 592   operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
 593 constexpr year_month_weekday_last
 594   operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
 595 constexpr year_month_weekday_last
 596   operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
 597
 598 template<class charT, class traits>
 599   basic_ostream<charT, traits>&
 600     operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
 601
 602 // 25.8.18, civil calendar conventional syntax operators    // C++20
 603 constexpr year_month
 604   operator/(const year& y, const month& m) noexcept;
 605 constexpr year_month
 606   operator/(const year& y, int m) noexcept;
 607 constexpr month_day
 608   operator/(const month& m, const day& d) noexcept;
 609 constexpr month_day
 610   operator/(const month& m, int d) noexcept;
 611 constexpr month_day
 612   operator/(int m, const day& d) noexcept;
 613 constexpr month_day
 614   operator/(const day& d, const month& m) noexcept;
 615 constexpr month_day
 616   operator/(const day& d, int m) noexcept;
 617 constexpr month_day_last
 618   operator/(const month& m, last_spec) noexcept;
 619 constexpr month_day_last
 620   operator/(int m, last_spec) noexcept;
 621 constexpr month_day_last
 622   operator/(last_spec, const month& m) noexcept;
 623 constexpr month_day_last
 624   operator/(last_spec, int m) noexcept;
 625 constexpr month_weekday
 626   operator/(const month& m, const weekday_indexed& wdi) noexcept;
 627 constexpr month_weekday
 628   operator/(int m, const weekday_indexed& wdi) noexcept;
 629 constexpr month_weekday
 630   operator/(const weekday_indexed& wdi, const month& m) noexcept;
 631 constexpr month_weekday
 632   operator/(const weekday_indexed& wdi, int m) noexcept;
 633 constexpr month_weekday_last
 634   operator/(const month& m, const weekday_last& wdl) noexcept;
 635 constexpr month_weekday_last
 636   operator/(int m, const weekday_last& wdl) noexcept;
 637 constexpr month_weekday_last
 638   operator/(const weekday_last& wdl, const month& m) noexcept;
 639 constexpr month_weekday_last
 640   operator/(const weekday_last& wdl, int m) noexcept;
 641 constexpr year_month_day
 642   operator/(const year_month& ym, const day& d) noexcept;
 643 constexpr year_month_day
 644   operator/(const year_month& ym, int d) noexcept;
 645 constexpr year_month_day
 646   operator/(const year& y, const month_day& md) noexcept;
 647 constexpr year_month_day
 648   operator/(int y, const month_day& md) noexcept;
 649 constexpr year_month_day
 650   operator/(const month_day& md, const year& y) noexcept;
 651 constexpr year_month_day
 652   operator/(const month_day& md, int y) noexcept;
 653 constexpr year_month_day_last
 654   operator/(const year_month& ym, last_spec) noexcept;
 655 constexpr year_month_day_last
 656   operator/(const year& y, const month_day_last& mdl) noexcept;
 657 constexpr year_month_day_last
 658   operator/(int y, const month_day_last& mdl) noexcept;
 659 constexpr year_month_day_last
 660   operator/(const month_day_last& mdl, const year& y) noexcept;
 661 constexpr year_month_day_last
 662   operator/(const month_day_last& mdl, int y) noexcept;
 663 constexpr year_month_weekday
 664   operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
 665 constexpr year_month_weekday
 666   operator/(const year& y, const month_weekday& mwd) noexcept;
 667 constexpr year_month_weekday
 668   operator/(int y, const month_weekday& mwd) noexcept;
 669 constexpr year_month_weekday
 670   operator/(const month_weekday& mwd, const year& y) noexcept;
 671 constexpr year_month_weekday
 672   operator/(const month_weekday& mwd, int y) noexcept;
 673 constexpr year_month_weekday_last
 674   operator/(const year_month& ym, const weekday_last& wdl) noexcept;
 675 constexpr year_month_weekday_last
 676   operator/(const year& y, const month_weekday_last& mwdl) noexcept;
 677 constexpr year_month_weekday_last
 678   operator/(int y, const month_weekday_last& mwdl) noexcept;
 679 constexpr year_month_weekday_last
 680   operator/(const month_weekday_last& mwdl, const year& y) noexcept;
 681 constexpr year_month_weekday_last
 682   operator/(const month_weekday_last& mwdl, int y) noexcept;
 683
 684 // 26.9, class template hh_mm_ss
 685 template <class Duration>
 686 class hh_mm_ss
 687 {
 688     bool            is_neg; // exposition only
 689     chrono::hours   h;      // exposition only
 690     chrono::minutes m;      // exposition only
 691     chrono::seconds s;      // exposition only
 692     precision       ss;     // exposition only
 693
 694 public:
 695     static unsigned constexpr fractional_width = see below;
 696     using precision                            = see below;
 697
 698     constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}
 699     constexpr explicit hh_mm_ss(Duration d) noexcept;
 700
 701     constexpr bool is_negative() const noexcept;
 702     constexpr chrono::hours hours() const noexcept;
 703     constexpr chrono::minutes minutes() const noexcept;
 704     constexpr chrono::seconds seconds() const noexcept;
 705     constexpr precision subseconds() const noexcept;
 706
 707     constexpr explicit operator  precision()   const noexcept;
 708     constexpr          precision to_duration() const noexcept;
 709 };
 710
 711 template<class charT, class traits, class Duration>
 712   basic_ostream<charT, traits>&
 713     operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms); // C++20
 714
 715 // 26.10, 12/24 hour functions
 716 constexpr bool is_am(hours const& h) noexcept;
 717 constexpr bool is_pm(hours const& h) noexcept;
 718 constexpr hours make12(const hours& h) noexcept;
 719 constexpr hours make24(const hours& h, bool is_pm) noexcept;
 720
 721 // [time.zone.db], time zone database
 722 struct tzdb {                                                                    // C++20
 723   string                 version;
 724   vector<time_zone>      zones;
 725   vector<time_zone_link> links;
 726   vector<leap_second>    leap_seconds;
 727
 728   const time_zone* locate_zone(string_view tz_name) const;
 729   const time_zone* current_zone() const;
 730 };
 731
 732 class tzdb_list {                                                                // C++20
 733 public:
 734   tzdb_list(const tzdb_list&) = delete;
 735   tzdb_list& operator=(const tzdb_list&) = delete;
 736
 737   // unspecified additional constructors
 738
 739   class const_iterator;
 740
 741   const tzdb& front() const noexcept;
 742
 743   const_iterator erase_after(const_iterator p);
 744
 745   const_iterator begin() const noexcept;
 746   const_iterator end()   const noexcept;
 747
 748   const_iterator cbegin() const noexcept;
 749   const_iterator cend()   const noexcept;
 750 };
 751
 752 // [time.zone.db.access], time zone database access
 753 const tzdb& get_tzdb();                                                          // C++20
 754 tzdb_list& get_tzdb_list();                                                      // C++20
 755 const time_zone* locate_zone(string_view tz_name);                               // C++20
 756 const time_zone* current_zone()                                                  // C++20
 757
 758 // [time.zone.db.remote], remote time zone database support
 759 const tzdb& reload_tzdb();                                                       // C++20
 760 string remote_version();                                                         // C++20
 761
 762 // [time.zone.exception], exception classes
 763 class nonexistent_local_time;                                                    // C++20
 764 class ambiguous_local_time;                                                      // C++20
 765
 766 // [time.zone.info], information classes
 767 struct sys_info {                                                                // C++20
 768   sys_seconds   begin;
 769   sys_seconds   end;
 770   seconds       offset;
 771   minutes       save;
 772   string        abbrev;
 773 };
 774
 775 template<class charT, class traits>                                              // C++20
 776   basic_ostream<charT, traits>&
 777     operator<<(basic_ostream<charT, traits>& os, const sys_info& si);
 778
 779 struct local_info {                                                             // C++20
 780   static constexpr int unique      = 0;
 781   static constexpr int nonexistent = 1;
 782   static constexpr int ambiguous   = 2;
 783
 784   int result;
 785   sys_info first;
 786   sys_info second;
 787 };
 788
 789 template<class charT, class traits>                                              // C++20
 790   basic_ostream<charT, traits>&
 791     operator<<(basic_ostream<charT, traits>& os, const local_info& li);
 792
 793 // 25.10.5, class time_zone                                                      // C++20
 794 enum class choose {earliest, latest};
 795 class time_zone {
 796   time_zone(time_zone&&) = default;
 797   time_zone& operator=(time_zone&&) = default;
 798
 799   // unspecified additional constructors
 800
 801   string_view name() const noexcept;
 802
 803   template<class Duration>
 804   sys_info get_info(const sys_time<Duration>& st) const;
 805
 806   template<class Duration>
 807   local_info get_info(const local_time<Duration>& tp) const;
 808
 809   template<class Duration>
 810   sys_time<common_type_t<Duration, seconds>>
 811     to_sys(const local_time<Duration>& tp) const;
 812
 813   template<class Duration>
 814   sys_time<common_type_t<Duration, seconds>>
 815     to_sys(const local_time<Duration>& tp, choose z) const;
 816
 817   template<class Duration>
 818   local_time<common_type_t<Duration, seconds>>
 819     to_local(const sys_time<Duration>& tp) const;
 820 };
 821 bool operator==(const time_zone& x, const time_zone& y) noexcept;                // C++20
 822 strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;    // C++20
 823
 824 // [time.zone.zonedtraits], class template zoned_traits
 825 template<class T> struct zoned_traits;                                           // C++20
 826
 827 // [time.zone.zonedtime], class template zoned_time
 828 template<class Duration, class TimeZonePtr = const time_zone*>                   // C++20
 829 class zoned_time;
 830
 831 using zoned_seconds = zoned_time<seconds>;                                       // C++20
 832
 833 template<class Duration1, class Duration2, class TimeZonePtr>                    // C++20
 834   bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
 835                   const zoned_time<Duration2, TimeZonePtr>& y);
 836
 837 template<class charT, class traits, class Duration, class TimeZonePtr>           // C++20
 838   basic_ostream<charT, traits>&
 839     operator<<(basic_ostream<charT, traits>& os,
 840                const zoned_time<Duration, TimeZonePtr>& t);
 841
 842 // [time.zone.leap], leap second support
 843 class leap_second {                                                              // C++20
 844 public:
 845   leap_second(const leap_second&)            = default;
 846   leap_second& operator=(const leap_second&) = default;
 847
 848   // unspecified additional constructors
 849
 850   constexpr sys_seconds date() const noexcept;
 851   constexpr seconds value() const noexcept;
 852 };
 853
 854 constexpr bool operator==(const leap_second& x, const leap_second& y);           // C++20
 855 constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y);
 856
 857 template<class Duration>                                                         // C++20
 858   constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
 859 template<class Duration>                                                         // C++20
 860   constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
 861 template<class Duration>                                                         // C++20
 862   constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
 863 template<class Duration>                                                         // C++20
 864   constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
 865 template<class Duration>                                                         // C++20
 866   constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
 867 template<class Duration>                                                         // C++20
 868   constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
 869 template<class Duration>                                                         // C++20
 870   constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
 871 template<class Duration>                                                         // C++20
 872   constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
 873 template<class Duration>                                                         // C++20
 874   constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
 875 template<class Duration>                                                         // C++20
 876   requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
 877   constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
 878
 879 // [time.zone.link], class time_zone_link
 880 class time_zone_link {                                                           // C++20
 881 public:
 882   time_zone_link(time_zone_link&&)            = default;
 883   time_zone_link& operator=(time_zone_link&&) = default;
 884
 885   // unspecified additional constructors
 886
 887   string_view name()   const noexcept;
 888   string_view target() const noexcept;
 889 };
 890
 891 bool operator==(const time_zone_link& x, const time_zone_link& y);               // C++20
 892 strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y);   // C++20
 893
 894 }  // chrono
 895
 896 namespace std {
 897   template<class Duration, class charT>
 898     struct formatter<chrono::sys_time<Duration>, charT>;                          // C++20
 899   template<class Duration, class charT>
 900     struct formatter<chrono::utc_time<Duration>, charT>;                          // C++20
 901   template<class Duration, class charT>
 902     struct formatter<chrono::filetime<Duration>, charT>;                          // C++20
 903   template<class Duration, class charT>
 904     struct formatter<chrono::local_time<Duration>, charT>;                        // C++20
 905   template<class Rep, class Period, class charT>
 906     struct formatter<chrono::duration<Rep, Period>, charT>;                       // C++20
 907   template<class charT> struct formatter<chrono::day, charT>;                     // C++20
 908   template<class charT> struct formatter<chrono::month, charT>;                   // C++20
 909   template<class charT> struct formatter<chrono::year, charT>;                    // C++20
 910   template<class charT> struct formatter<chrono::weekday, charT>;                 // C++20
 911   template<class charT> struct formatter<chrono::weekday_indexed, charT>;         // C++20
 912   template<class charT> struct formatter<chrono::weekday_last, charT>;            // C++20
 913   template<class charT> struct formatter<chrono::month_day, charT>;               // C++20
 914   template<class charT> struct formatter<chrono::month_day_last, charT>;          // C++20
 915   template<class charT> struct formatter<chrono::month_weekday, charT>;           // C++20
 916   template<class charT> struct formatter<chrono::month_weekday_last, charT>;      // C++20
 917   template<class charT> struct formatter<chrono::year_month, charT>;              // C++20
 918   template<class charT> struct formatter<chrono::year_month_day, charT>;          // C++20
 919   template<class charT> struct formatter<chrono::year_month_day_last, charT>;     // C++20
 920   template<class charT> struct formatter<chrono::year_month_weekday, charT>;      // C++20
 921   template<class charT> struct formatter<chrono::year_month_weekday_last, charT>; // C++20
 922   template<class Rep, class Period, class charT>
 923     struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;             // C++20
 924   template<class charT> struct formatter<chrono::sys_info, charT>;                // C++20
 925   template<class charT> struct formatter<chrono::local_info, charT>;              // C++20
 926   template<class Duration, class TimeZonePtr, class charT>                        // C++20
 927     struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;
 928 } // namespace std
 929
 930 namespace chrono {
 931 // calendrical constants
 932 inline constexpr last_spec                              last{};       // C++20
 933 inline constexpr chrono::weekday                        Sunday{0};    // C++20
 934 inline constexpr chrono::weekday                        Monday{1};    // C++20
 935 inline constexpr chrono::weekday                        Tuesday{2};   // C++20
 936 inline constexpr chrono::weekday                        Wednesday{3}; // C++20
 937 inline constexpr chrono::weekday                        Thursday{4};  // C++20
 938 inline constexpr chrono::weekday                        Friday{5};    // C++20
 939 inline constexpr chrono::weekday                        Saturday{6};  // C++20
 940
 941 inline constexpr chrono::month                          January{1};   // C++20
 942 inline constexpr chrono::month                          February{2};  // C++20
 943 inline constexpr chrono::month                          March{3};     // C++20
 944 inline constexpr chrono::month                          April{4};     // C++20
 945 inline constexpr chrono::month                          May{5};       // C++20
 946 inline constexpr chrono::month                          June{6};      // C++20
 947 inline constexpr chrono::month                          July{7};      // C++20
 948 inline constexpr chrono::month                          August{8};    // C++20
 949 inline constexpr chrono::month                          September{9}; // C++20
 950 inline constexpr chrono::month                          October{10};  // C++20
 951 inline constexpr chrono::month                          November{11}; // C++20
 952 inline constexpr chrono::month                          December{12}; // C++20
 953 }  // chrono
 954
 955 inline namespace literals {
 956   inline namespace chrono_literals {
 957 constexpr chrono::hours                                 operator ""h(unsigned long long); // C++14
 958 constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14
 959 constexpr chrono::minutes                               operator ""min(unsigned long long); // C++14
 960 constexpr chrono::duration<unspecified , ratio<60,1>>   operator ""min(long double); // C++14
 961 constexpr chrono::seconds                               operator ""s(unsigned long long); // C++14
 962 constexpr chrono::duration<unspecified >                operator ""s(long double); // C++14
 963 constexpr chrono::milliseconds                          operator ""ms(unsigned long long); // C++14
 964 constexpr chrono::duration<unspecified , milli>         operator ""ms(long double); // C++14
 965 constexpr chrono::microseconds                          operator ""us(unsigned long long); // C++14
 966 constexpr chrono::duration<unspecified , micro>         operator ""us(long double); // C++14
 967 constexpr chrono::nanoseconds                           operator ""ns(unsigned long long); // C++14
 968 constexpr chrono::duration<unspecified , nano>          operator ""ns(long double); // C++14
 969 constexpr chrono::day                                   operator ""d(unsigned long long d) noexcept; // C++20
 970 constexpr chrono::year                                  operator ""y(unsigned long long y) noexcept; // C++20
 971 }  // chrono_literals
 972 }  // literals
 973
 974 }  // std
 975 */
 976
 977 // clang-format on
 978
 979 #if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
 980 #  include <__cxx03/chrono>
 981 #else
 982 #  include <__config>
 983
 984 #  include <__chrono/duration.h>
 985 #  include <__chrono/file_clock.h>
 986 #  include <__chrono/high_resolution_clock.h>
 987 #  include <__chrono/steady_clock.h>
 988 #  include <__chrono/system_clock.h>
 989 #  include <__chrono/time_point.h>
 990
 991 #  if _LIBCPP_STD_VER >= 20
 992 #    include <__chrono/calendar.h>
 993 #    include <__chrono/day.h>
 994 #    include <__chrono/exception.h>
 995 #    include <__chrono/hh_mm_ss.h>
 996 #    include <__chrono/literals.h>
 997 #    include <__chrono/local_info.h>
 998 #    include <__chrono/month.h>
 999 #    include <__chrono/month_weekday.h>
1000 #    include <__chrono/monthday.h>
1001 #    include <__chrono/sys_info.h>
1002 #    include <__chrono/weekday.h>
1003 #    include <__chrono/year.h>
1004 #    include <__chrono/year_month.h>
1005 #    include <__chrono/year_month_day.h>
1006 #    include <__chrono/year_month_weekday.h>
1007
1008 #    if _LIBCPP_HAS_LOCALIZATION
1009 #      include <__chrono/formatter.h>
1010 #      include <__chrono/ostream.h>
1011 #      include <__chrono/parser_std_format_spec.h>
1012 #      include <__chrono/statically_widen.h>
1013 #    endif
1014
1015 #    if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
1016 #      include <__chrono/leap_second.h>
1017 #      include <__chrono/time_zone.h>
1018 #      include <__chrono/time_zone_link.h>
1019 #      include <__chrono/tzdb.h>
1020 #      include <__chrono/tzdb_list.h>
1021 #      include <__chrono/utc_clock.h>
1022 #      include <__chrono/zoned_time.h>
1023 #    endif
1024
1025 #  endif
1026
1027 #  include <version>
1028
1029 // standard-mandated includes
1030
1031 // [time.syn]
1032 #  include <compare>
1033
1034 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
1035 #    pragma GCC system_header
1036 #  endif
1037
1038 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
1039 #    include <cstdint>
1040 #    include <stdexcept>
1041 #    include <string_view>
1042 #  endif
1043
1044 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1045 #    include <bit>
1046 #    include <concepts>
1047 #    include <cstring>
1048 #    include <forward_list>
1049 #    include <string>
1050 #    include <tuple>
1051 #    include <vector>
1052 #  endif
1053
1054 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20
1055 #    include <charconv>
1056 #    if _LIBCPP_HAS_LOCALIZATION
1057 #      include <locale>
1058 #      include <ostream>
1059 #    endif
1060 #  endif
1061 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1062
1063 #endif // _LIBCPP_CHRONO