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
 339 // [time.clock.tai], class tai_clock
 340 class tai_clock {                                      // C++20
 341 public:
 342     using rep                       = a signed arithmetic type;
 343     using period                    = ratio<unspecified, unspecified>;
 344     using duration                  = chrono::duration<rep, period>;
 345     using time_point                = chrono::time_point<tai_clock>;
 346     static constexpr bool is_steady = unspecified;
 347
 348     static time_point now();
 349
 350     template<class Duration>
 351       static utc_time<common_type_t<Duration, seconds>>
 352         to_utc(const tai_time<Duration>& t);
 353     template<class Duration>
 354       static tai_time<common_type_t<Duration, seconds>>
 355         from_utc(const utc_time<Duration>& t);
 356 };
 357
 358 template<class Duration>
 359 using tai_time  = time_point<tai_clock, Duration>;      // C++20
 360 using tai_seconds = tai_time<seconds>;                  // C++20
 361
 362 template<class charT, class traits, class Duration>     // C++20
 363   basic_ostream<charT, traits>&
 364     operator<<(basic_ostream<charT, traits>& os, const tai_time<Duration>& t);
 365
 366 class file_clock                                        // C++20
 367 {
 368 public:
 369     typedef see-below                      rep;
 370     typedef nano                           period;
 371     typedef chrono::duration<rep, period>  duration;
 372     typedef chrono::time_point<file_clock> time_point;
 373     static constexpr bool is_steady =      false;
 374
 375     static time_point now() noexcept;
 376
 377     template<class Duration>
 378     static sys_time<see-below> to_sys(const file_time<Duration>&);
 379
 380     template<class Duration>
 381     static file_time<see-below> from_sys(const sys_time<Duration>&);
 382 };
 383
 384 template<class Duration>
 385   using file_time = time_point<file_clock, Duration>;   // C++20
 386
 387 template<class charT, class traits, class Duration>     // C++20
 388   basic_ostream<charT, traits>&
 389     operator<<(basic_ostream<charT, traits>& os, const file_time<Duration>& tp);
 390
 391 class steady_clock
 392 {
 393 public:
 394     typedef nanoseconds                                   duration;
 395     typedef duration::rep                                 rep;
 396     typedef duration::period                              period;
 397     typedef chrono::time_point<steady_clock, duration>    time_point;
 398     static const bool is_steady =                         true; // constexpr in C++14
 399
 400     static time_point now() noexcept;
 401 };
 402
 403 typedef steady_clock high_resolution_clock;
 404
 405 // 25.7.8, local time           // C++20
 406 struct local_t {};
 407 template<class Duration>
 408   using local_time  = time_point<local_t, Duration>;
 409 using local_seconds = local_time<seconds>;
 410 using local_days    = local_time<days>;
 411
 412 template<class charT, class traits, class Duration>     // C++20
 413   basic_ostream<charT, traits>&
 414     operator<<(basic_ostream<charT, traits>& os, const local_time<Duration>& tp);
 415
 416 // 25.8.2, class last_spec    // C++20
 417 struct last_spec;
 418
 419 // 25.8.3, class day          // C++20
 420
 421 class day;
 422 constexpr bool operator==(const day& x, const day& y) noexcept;
 423 constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
 424 constexpr day  operator+(const day&  x, const days& y) noexcept;
 425 constexpr day  operator+(const days& x, const day&  y) noexcept;
 426 constexpr day  operator-(const day&  x, const days& y) noexcept;
 427 constexpr days operator-(const day&  x, const day&  y) noexcept;
 428 template<class charT, class traits>
 429   basic_ostream<charT, traits>&
 430     operator<<(basic_ostream<charT, traits>& os, const day& d);
 431
 432 // 25.8.4, class month    // C++20
 433 class month;
 434 constexpr bool operator==(const month& x, const month& y) noexcept;
 435 constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
 436
 437 constexpr month  operator+(const month&  x, const months& y) noexcept;
 438 constexpr month  operator+(const months& x,  const month& y) noexcept;
 439 constexpr month  operator-(const month&  x, const months& y) noexcept;
 440 constexpr months operator-(const month&  x,  const month& y) noexcept;
 441 template<class charT, class traits>
 442   basic_ostream<charT, traits>&
 443     operator<<(basic_ostream<charT, traits>& os, const month& m);
 444
 445 // 25.8.5, class year    // C++20
 446 class year;
 447 constexpr bool operator==(const year& x, const year& y) noexcept;
 448 constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
 449
 450 constexpr year  operator+(const year&  x, const years& y) noexcept;
 451 constexpr year  operator+(const years& x, const year&  y) noexcept;
 452 constexpr year  operator-(const year&  x, const years& y) noexcept;
 453 constexpr years operator-(const year&  x, const year&  y) noexcept;
 454 template<class charT, class traits>
 455   basic_ostream<charT, traits>&
 456     operator<<(basic_ostream<charT, traits>& os, const year& y);
 457
 458 // 25.8.6, class weekday    // C++20
 459 class weekday;
 460
 461 constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
 462 constexpr weekday operator+(const weekday& x, const days&    y) noexcept;
 463 constexpr weekday operator+(const days&    x, const weekday& y) noexcept;
 464 constexpr weekday operator-(const weekday& x, const days&    y) noexcept;
 465 constexpr days    operator-(const weekday& x, const weekday& y) noexcept;
 466 template<class charT, class traits>
 467   basic_ostream<charT, traits>&
 468     operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
 469
 470 // 25.8.7, class weekday_indexed    // C++20
 471
 472 class weekday_indexed;
 473 constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 474
 475 template<class charT, class traits>
 476   basic_ostream<charT, traits>&
 477     operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
 478
 479 // 25.8.8, class weekday_last    // C++20
 480 class weekday_last;
 481
 482 constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
 483
 484 template<class charT, class traits>
 485   basic_ostream<charT, traits>&
 486     operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
 487
 488 // 25.8.9, class month_day    // C++20
 489 class month_day;
 490
 491 constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
 492 constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
 493
 494 template<class charT, class traits>
 495   basic_ostream<charT, traits>&
 496     operator<<(basic_ostream<charT, traits>& os, const month_day& md);
 497
 498 // 25.8.10, class month_day_last    // C++20
 499 class month_day_last;
 500
 501 constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
 502 constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
 503
 504 template<class charT, class traits>
 505   basic_ostream<charT, traits>&
 506     operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
 507
 508 // 25.8.11, class month_weekday    // C++20
 509 class month_weekday;
 510
 511 constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
 512
 513 template<class charT, class traits>
 514   basic_ostream<charT, traits>&
 515     operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
 516
 517 // 25.8.12, class month_weekday_last    // C++20
 518 class month_weekday_last;
 519
 520 constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
 521
 522 template<class charT, class traits>
 523   basic_ostream<charT, traits>&
 524     operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mwdl);
 525
 526
 527 // 25.8.13, class year_month    // C++20
 528 class year_month;
 529
 530 constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
 531 constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
 532
 533 constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
 534 constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
 535 constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
 536 constexpr months operator-(const year_month& x, const year_month& y) noexcept;
 537 constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
 538 constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
 539 constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
 540
 541 template<class charT, class traits>
 542   basic_ostream<charT, traits>&
 543     operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
 544
 545 // 25.8.14, class year_month_day class    // C++20
 546 year_month_day;
 547
 548 constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
 549 constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
 550
 551 constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
 552 constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
 553 constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
 554 constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
 555 constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
 556 constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
 557
 558 template<class charT, class traits>
 559   basic_ostream<charT, traits>&
 560     operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
 561
 562 // 25.8.15, class year_month_day_last    // C++20
 563 class year_month_day_last;
 564
 565 constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
 566 constexpr strong_ordering operator<=>(const year_month_day_last_day& x, const year_month_day_last_day& y) noexcept;
 567
 568 constexpr year_month_day_last
 569   operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
 570 constexpr year_month_day_last
 571   operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
 572 constexpr year_month_day_last
 573   operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
 574 constexpr year_month_day_last
 575   operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
 576 constexpr year_month_day_last
 577   operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
 578 constexpr year_month_day_last
 579   operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
 580
 581 template<class charT, class traits>
 582   basic_ostream<charT, traits>&
 583     operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
 584
 585 // 25.8.16, class year_month_weekday    // C++20
 586 class year_month_weekday;
 587
 588 constexpr bool operator==(const year_month_weekday& x,
 589                           const year_month_weekday& y) noexcept;
 590
 591 constexpr year_month_weekday
 592   operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
 593 constexpr year_month_weekday
 594   operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
 595 constexpr year_month_weekday
 596   operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
 597 constexpr year_month_weekday
 598   operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
 599 constexpr year_month_weekday
 600   operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
 601 constexpr year_month_weekday
 602   operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
 603
 604 template<class charT, class traits>
 605   basic_ostream<charT, traits>&
 606     operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
 607
 608 // 25.8.17, class year_month_weekday_last    // C++20
 609 class year_month_weekday_last;
 610
 611 constexpr bool operator==(const year_month_weekday_last& x,
 612                           const year_month_weekday_last& y) noexcept;
 613 constexpr year_month_weekday_last
 614   operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
 615 constexpr year_month_weekday_last
 616   operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
 617 constexpr year_month_weekday_last
 618   operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
 619 constexpr year_month_weekday_last
 620   operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
 621 constexpr year_month_weekday_last
 622   operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
 623 constexpr year_month_weekday_last
 624   operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
 625
 626 template<class charT, class traits>
 627   basic_ostream<charT, traits>&
 628     operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
 629
 630 // 25.8.18, civil calendar conventional syntax operators    // C++20
 631 constexpr year_month
 632   operator/(const year& y, const month& m) noexcept;
 633 constexpr year_month
 634   operator/(const year& y, int m) noexcept;
 635 constexpr month_day
 636   operator/(const month& m, const day& d) noexcept;
 637 constexpr month_day
 638   operator/(const month& m, int d) noexcept;
 639 constexpr month_day
 640   operator/(int m, const day& d) noexcept;
 641 constexpr month_day
 642   operator/(const day& d, const month& m) noexcept;
 643 constexpr month_day
 644   operator/(const day& d, int m) noexcept;
 645 constexpr month_day_last
 646   operator/(const month& m, last_spec) noexcept;
 647 constexpr month_day_last
 648   operator/(int m, last_spec) noexcept;
 649 constexpr month_day_last
 650   operator/(last_spec, const month& m) noexcept;
 651 constexpr month_day_last
 652   operator/(last_spec, int m) noexcept;
 653 constexpr month_weekday
 654   operator/(const month& m, const weekday_indexed& wdi) noexcept;
 655 constexpr month_weekday
 656   operator/(int m, const weekday_indexed& wdi) noexcept;
 657 constexpr month_weekday
 658   operator/(const weekday_indexed& wdi, const month& m) noexcept;
 659 constexpr month_weekday
 660   operator/(const weekday_indexed& wdi, int m) noexcept;
 661 constexpr month_weekday_last
 662   operator/(const month& m, const weekday_last& wdl) noexcept;
 663 constexpr month_weekday_last
 664   operator/(int m, const weekday_last& wdl) noexcept;
 665 constexpr month_weekday_last
 666   operator/(const weekday_last& wdl, const month& m) noexcept;
 667 constexpr month_weekday_last
 668   operator/(const weekday_last& wdl, int m) noexcept;
 669 constexpr year_month_day
 670   operator/(const year_month& ym, const day& d) noexcept;
 671 constexpr year_month_day
 672   operator/(const year_month& ym, int d) noexcept;
 673 constexpr year_month_day
 674   operator/(const year& y, const month_day& md) noexcept;
 675 constexpr year_month_day
 676   operator/(int y, const month_day& md) noexcept;
 677 constexpr year_month_day
 678   operator/(const month_day& md, const year& y) noexcept;
 679 constexpr year_month_day
 680   operator/(const month_day& md, int y) noexcept;
 681 constexpr year_month_day_last
 682   operator/(const year_month& ym, last_spec) noexcept;
 683 constexpr year_month_day_last
 684   operator/(const year& y, const month_day_last& mdl) noexcept;
 685 constexpr year_month_day_last
 686   operator/(int y, const month_day_last& mdl) noexcept;
 687 constexpr year_month_day_last
 688   operator/(const month_day_last& mdl, const year& y) noexcept;
 689 constexpr year_month_day_last
 690   operator/(const month_day_last& mdl, int y) noexcept;
 691 constexpr year_month_weekday
 692   operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
 693 constexpr year_month_weekday
 694   operator/(const year& y, const month_weekday& mwd) noexcept;
 695 constexpr year_month_weekday
 696   operator/(int y, const month_weekday& mwd) noexcept;
 697 constexpr year_month_weekday
 698   operator/(const month_weekday& mwd, const year& y) noexcept;
 699 constexpr year_month_weekday
 700   operator/(const month_weekday& mwd, int y) noexcept;
 701 constexpr year_month_weekday_last
 702   operator/(const year_month& ym, const weekday_last& wdl) noexcept;
 703 constexpr year_month_weekday_last
 704   operator/(const year& y, const month_weekday_last& mwdl) noexcept;
 705 constexpr year_month_weekday_last
 706   operator/(int y, const month_weekday_last& mwdl) noexcept;
 707 constexpr year_month_weekday_last
 708   operator/(const month_weekday_last& mwdl, const year& y) noexcept;
 709 constexpr year_month_weekday_last
 710   operator/(const month_weekday_last& mwdl, int y) noexcept;
 711
 712 // 26.9, class template hh_mm_ss
 713 template <class Duration>
 714 class hh_mm_ss
 715 {
 716     bool            is_neg; // exposition only
 717     chrono::hours   h;      // exposition only
 718     chrono::minutes m;      // exposition only
 719     chrono::seconds s;      // exposition only
 720     precision       ss;     // exposition only
 721
 722 public:
 723     static unsigned constexpr fractional_width = see below;
 724     using precision                            = see below;
 725
 726     constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}
 727     constexpr explicit hh_mm_ss(Duration d) noexcept;
 728
 729     constexpr bool is_negative() const noexcept;
 730     constexpr chrono::hours hours() const noexcept;
 731     constexpr chrono::minutes minutes() const noexcept;
 732     constexpr chrono::seconds seconds() const noexcept;
 733     constexpr precision subseconds() const noexcept;
 734
 735     constexpr explicit operator  precision()   const noexcept;
 736     constexpr          precision to_duration() const noexcept;
 737 };
 738
 739 template<class charT, class traits, class Duration>
 740   basic_ostream<charT, traits>&
 741     operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms); // C++20
 742
 743 // 26.10, 12/24 hour functions
 744 constexpr bool is_am(hours const& h) noexcept;
 745 constexpr bool is_pm(hours const& h) noexcept;
 746 constexpr hours make12(const hours& h) noexcept;
 747 constexpr hours make24(const hours& h, bool is_pm) noexcept;
 748
 749 // [time.zone.db], time zone database
 750 struct tzdb {                                                                    // C++20
 751   string                 version;
 752   vector<time_zone>      zones;
 753   vector<time_zone_link> links;
 754   vector<leap_second>    leap_seconds;
 755
 756   const time_zone* locate_zone(string_view tz_name) const;
 757   const time_zone* current_zone() const;
 758 };
 759
 760 class tzdb_list {                                                                // C++20
 761 public:
 762   tzdb_list(const tzdb_list&) = delete;
 763   tzdb_list& operator=(const tzdb_list&) = delete;
 764
 765   // unspecified additional constructors
 766
 767   class const_iterator;
 768
 769   const tzdb& front() const noexcept;
 770
 771   const_iterator erase_after(const_iterator p);
 772
 773   const_iterator begin() const noexcept;
 774   const_iterator end()   const noexcept;
 775
 776   const_iterator cbegin() const noexcept;
 777   const_iterator cend()   const noexcept;
 778 };
 779
 780 // [time.zone.db.access], time zone database access
 781 const tzdb& get_tzdb();                                                          // C++20
 782 tzdb_list& get_tzdb_list();                                                      // C++20
 783 const time_zone* locate_zone(string_view tz_name);                               // C++20
 784 const time_zone* current_zone()                                                  // C++20
 785
 786 // [time.zone.db.remote], remote time zone database support
 787 const tzdb& reload_tzdb();                                                       // C++20
 788 string remote_version();                                                         // C++20
 789
 790 // [time.zone.exception], exception classes
 791 class nonexistent_local_time;                                                    // C++20
 792 class ambiguous_local_time;                                                      // C++20
 793
 794 // [time.zone.info], information classes
 795 struct sys_info {                                                                // C++20
 796   sys_seconds   begin;
 797   sys_seconds   end;
 798   seconds       offset;
 799   minutes       save;
 800   string        abbrev;
 801 };
 802
 803 template<class charT, class traits>                                              // C++20
 804   basic_ostream<charT, traits>&
 805     operator<<(basic_ostream<charT, traits>& os, const sys_info& si);
 806
 807 struct local_info {                                                             // C++20
 808   static constexpr int unique      = 0;
 809   static constexpr int nonexistent = 1;
 810   static constexpr int ambiguous   = 2;
 811
 812   int result;
 813   sys_info first;
 814   sys_info second;
 815 };
 816
 817 template<class charT, class traits>                                              // C++20
 818   basic_ostream<charT, traits>&
 819     operator<<(basic_ostream<charT, traits>& os, const local_info& li);
 820
 821 // 25.10.5, class time_zone                                                      // C++20
 822 enum class choose {earliest, latest};
 823 class time_zone {
 824   time_zone(time_zone&&) = default;
 825   time_zone& operator=(time_zone&&) = default;
 826
 827   // unspecified additional constructors
 828
 829   string_view name() const noexcept;
 830
 831   template<class Duration>
 832   sys_info get_info(const sys_time<Duration>& st) const;
 833
 834   template<class Duration>
 835   local_info get_info(const local_time<Duration>& tp) const;
 836
 837   template<class Duration>
 838   sys_time<common_type_t<Duration, seconds>>
 839     to_sys(const local_time<Duration>& tp) const;
 840
 841   template<class Duration>
 842   sys_time<common_type_t<Duration, seconds>>
 843     to_sys(const local_time<Duration>& tp, choose z) const;
 844
 845   template<class Duration>
 846   local_time<common_type_t<Duration, seconds>>
 847     to_local(const sys_time<Duration>& tp) const;
 848 };
 849 bool operator==(const time_zone& x, const time_zone& y) noexcept;                // C++20
 850 strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;    // C++20
 851
 852 // [time.zone.zonedtraits], class template zoned_traits
 853 template<class T> struct zoned_traits;                                           // C++20
 854
 855 // [time.zone.zonedtime], class template zoned_time
 856 template<class Duration, class TimeZonePtr = const time_zone*>                   // C++20
 857 class zoned_time;
 858
 859 using zoned_seconds = zoned_time<seconds>;                                       // C++20
 860
 861 template<class Duration1, class Duration2, class TimeZonePtr>                    // C++20
 862   bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
 863                   const zoned_time<Duration2, TimeZonePtr>& y);
 864
 865 template<class charT, class traits, class Duration, class TimeZonePtr>           // C++20
 866   basic_ostream<charT, traits>&
 867     operator<<(basic_ostream<charT, traits>& os,
 868                const zoned_time<Duration, TimeZonePtr>& t);
 869
 870 // [time.zone.leap], leap second support
 871 class leap_second {                                                              // C++20
 872 public:
 873   leap_second(const leap_second&)            = default;
 874   leap_second& operator=(const leap_second&) = default;
 875
 876   // unspecified additional constructors
 877
 878   constexpr sys_seconds date() const noexcept;
 879   constexpr seconds value() const noexcept;
 880 };
 881
 882 constexpr bool operator==(const leap_second& x, const leap_second& y);           // C++20
 883 constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y);
 884
 885 template<class Duration>                                                         // C++20
 886   constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
 887 template<class Duration>                                                         // C++20
 888   constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
 889 template<class Duration>                                                         // C++20
 890   constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
 891 template<class Duration>                                                         // C++20
 892   constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
 893 template<class Duration>                                                         // C++20
 894   constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
 895 template<class Duration>                                                         // C++20
 896   constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
 897 template<class Duration>                                                         // C++20
 898   constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
 899 template<class Duration>                                                         // C++20
 900   constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
 901 template<class Duration>                                                         // C++20
 902   constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
 903 template<class Duration>                                                         // C++20
 904   requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
 905   constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
 906
 907 // [time.zone.link], class time_zone_link
 908 class time_zone_link {                                                           // C++20
 909 public:
 910   time_zone_link(time_zone_link&&)            = default;
 911   time_zone_link& operator=(time_zone_link&&) = default;
 912
 913   // unspecified additional constructors
 914
 915   string_view name()   const noexcept;
 916   string_view target() const noexcept;
 917 };
 918
 919 bool operator==(const time_zone_link& x, const time_zone_link& y);               // C++20
 920 strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y);   // C++20
 921
 922 }  // chrono
 923
 924 namespace std {
 925   template<class Duration, class charT>
 926     struct formatter<chrono::sys_time<Duration>, charT>;                          // C++20
 927   template<class Duration, class charT>
 928     struct formatter<chrono::utc_time<Duration>, charT>;                          // C++20
 929   template<class Duration, class charT>
 930     struct formatter<chrono::tai_time<Duration>, charT>;                          // C++20
 931   template<class Duration, class charT>
 932     struct formatter<chrono::filetime<Duration>, charT>;                          // C++20
 933   template<class Duration, class charT>
 934     struct formatter<chrono::local_time<Duration>, charT>;                        // C++20
 935   template<class Rep, class Period, class charT>
 936     struct formatter<chrono::duration<Rep, Period>, charT>;                       // C++20
 937   template<class charT> struct formatter<chrono::day, charT>;                     // C++20
 938   template<class charT> struct formatter<chrono::month, charT>;                   // C++20
 939   template<class charT> struct formatter<chrono::year, charT>;                    // C++20
 940   template<class charT> struct formatter<chrono::weekday, charT>;                 // C++20
 941   template<class charT> struct formatter<chrono::weekday_indexed, charT>;         // C++20
 942   template<class charT> struct formatter<chrono::weekday_last, charT>;            // C++20
 943   template<class charT> struct formatter<chrono::month_day, charT>;               // C++20
 944   template<class charT> struct formatter<chrono::month_day_last, charT>;          // C++20
 945   template<class charT> struct formatter<chrono::month_weekday, charT>;           // C++20
 946   template<class charT> struct formatter<chrono::month_weekday_last, charT>;      // C++20
 947   template<class charT> struct formatter<chrono::year_month, charT>;              // C++20
 948   template<class charT> struct formatter<chrono::year_month_day, charT>;          // C++20
 949   template<class charT> struct formatter<chrono::year_month_day_last, charT>;     // C++20
 950   template<class charT> struct formatter<chrono::year_month_weekday, charT>;      // C++20
 951   template<class charT> struct formatter<chrono::year_month_weekday_last, charT>; // C++20
 952   template<class Rep, class Period, class charT>
 953     struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;             // C++20
 954   template<class charT> struct formatter<chrono::sys_info, charT>;                // C++20
 955   template<class charT> struct formatter<chrono::local_info, charT>;              // C++20
 956   template<class Duration, class TimeZonePtr, class charT>                        // C++20
 957     struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;
 958 } // namespace std
 959
 960 namespace chrono {
 961 // calendrical constants
 962 inline constexpr last_spec                              last{};       // C++20
 963 inline constexpr chrono::weekday                        Sunday{0};    // C++20
 964 inline constexpr chrono::weekday                        Monday{1};    // C++20
 965 inline constexpr chrono::weekday                        Tuesday{2};   // C++20
 966 inline constexpr chrono::weekday                        Wednesday{3}; // C++20
 967 inline constexpr chrono::weekday                        Thursday{4};  // C++20
 968 inline constexpr chrono::weekday                        Friday{5};    // C++20
 969 inline constexpr chrono::weekday                        Saturday{6};  // C++20
 970
 971 inline constexpr chrono::month                          January{1};   // C++20
 972 inline constexpr chrono::month                          February{2};  // C++20
 973 inline constexpr chrono::month                          March{3};     // C++20
 974 inline constexpr chrono::month                          April{4};     // C++20
 975 inline constexpr chrono::month                          May{5};       // C++20
 976 inline constexpr chrono::month                          June{6};      // C++20
 977 inline constexpr chrono::month                          July{7};      // C++20
 978 inline constexpr chrono::month                          August{8};    // C++20
 979 inline constexpr chrono::month                          September{9}; // C++20
 980 inline constexpr chrono::month                          October{10};  // C++20
 981 inline constexpr chrono::month                          November{11}; // C++20
 982 inline constexpr chrono::month                          December{12}; // C++20
 983 }  // chrono
 984
 985 inline namespace literals {
 986   inline namespace chrono_literals {
 987 constexpr chrono::hours                                 operator ""h(unsigned long long); // C++14
 988 constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14
 989 constexpr chrono::minutes                               operator ""min(unsigned long long); // C++14
 990 constexpr chrono::duration<unspecified , ratio<60,1>>   operator ""min(long double); // C++14
 991 constexpr chrono::seconds                               operator ""s(unsigned long long); // C++14
 992 constexpr chrono::duration<unspecified >                operator ""s(long double); // C++14
 993 constexpr chrono::milliseconds                          operator ""ms(unsigned long long); // C++14
 994 constexpr chrono::duration<unspecified , milli>         operator ""ms(long double); // C++14
 995 constexpr chrono::microseconds                          operator ""us(unsigned long long); // C++14
 996 constexpr chrono::duration<unspecified , micro>         operator ""us(long double); // C++14
 997 constexpr chrono::nanoseconds                           operator ""ns(unsigned long long); // C++14
 998 constexpr chrono::duration<unspecified , nano>          operator ""ns(long double); // C++14
 999 constexpr chrono::day                                   operator ""d(unsigned long long d) noexcept; // C++20
1000 constexpr chrono::year                                  operator ""y(unsigned long long y) noexcept; // C++20
1001 }  // chrono_literals
1002 }  // literals
1003
1004 }  // std
1005 */
1006
1007 // clang-format on
1008
1009 #if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1010 #  include <__cxx03/chrono>
1011 #else
1012 #  include <__config>
1013
1014 #  include <__chrono/duration.h>
1015 #  include <__chrono/file_clock.h>
1016 #  include <__chrono/high_resolution_clock.h>
1017 #  include <__chrono/steady_clock.h>
1018 #  include <__chrono/system_clock.h>
1019 #  include <__chrono/time_point.h>
1020
1021 #  if _LIBCPP_STD_VER >= 20
1022 #    include <__chrono/calendar.h>
1023 #    include <__chrono/day.h>
1024 #    include <__chrono/exception.h>
1025 #    include <__chrono/hh_mm_ss.h>
1026 #    include <__chrono/literals.h>
1027 #    include <__chrono/local_info.h>
1028 #    include <__chrono/month.h>
1029 #    include <__chrono/month_weekday.h>
1030 #    include <__chrono/monthday.h>
1031 #    include <__chrono/sys_info.h>
1032 #    include <__chrono/weekday.h>
1033 #    include <__chrono/year.h>
1034 #    include <__chrono/year_month.h>
1035 #    include <__chrono/year_month_day.h>
1036 #    include <__chrono/year_month_weekday.h>
1037
1038 #    if _LIBCPP_HAS_LOCALIZATION
1039 #      include <__chrono/formatter.h>
1040 #      include <__chrono/ostream.h>
1041 #      include <__chrono/parser_std_format_spec.h>
1042 #      include <__chrono/statically_widen.h>
1043 #    endif
1044
1045 #    if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
1046 #      include <__chrono/leap_second.h>
1047 #      include <__chrono/tai_clock.h>
1048 #      include <__chrono/time_zone.h>
1049 #      include <__chrono/time_zone_link.h>
1050 #      include <__chrono/tzdb.h>
1051 #      include <__chrono/tzdb_list.h>
1052 #      include <__chrono/utc_clock.h>
1053 #      include <__chrono/zoned_time.h>
1054 #    endif
1055
1056 #  endif
1057
1058 #  include <version>
1059
1060 // standard-mandated includes
1061
1062 // [time.syn]
1063 #  include <compare>
1064
1065 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
1066 #    pragma GCC system_header
1067 #  endif
1068
1069 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
1070 #    include <cstdint>
1071 #    include <stdexcept>
1072 #    include <string_view>
1073 #  endif
1074
1075 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1076 #    include <bit>
1077 #    include <concepts>
1078 #    include <cstring>
1079 #    include <forward_list>
1080 #    include <string>
1081 #    include <tuple>
1082 #    include <vector>
1083 #  endif
1084
1085 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20
1086 #    include <charconv>
1087 #    if _LIBCPP_HAS_LOCALIZATION
1088 #      include <locale>
1089 #      include <ostream>
1090 #    endif
1091 #  endif
1092 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1093
1094 #endif // _LIBCPP_CHRONO