1134 lines · plain
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-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_CHRONO11#define _LIBCPP_CHRONO12 13// clang-format off14 15/*16 chrono synopsis17 18#include <compare> // C++2019 20namespace std21{22namespace chrono23{24 25template <class ToDuration, class Rep, class Period>26constexpr27ToDuration28duration_cast(const duration<Rep, Period>& fd);29 30template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};31 32template <class Rep> inline constexpr bool treat_as_floating_point_v33 = treat_as_floating_point<Rep>::value; // C++1734 35template <class Rep>36struct duration_values37{38public:39 static constexpr Rep zero(); // noexcept in C++2040 static constexpr Rep max(); // noexcept in C++2041 static constexpr Rep min(); // noexcept in C++2042};43 44// duration45 46template <class Rep, class Period = ratio<1>>47class duration48{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");52public: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_if60 <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 // conversions67 template <class Rep2, class Period2>68 constexpr duration(const duration<Rep2, Period2>& d,69 typename enable_if70 <71 treat_as_floating_point<rep>::value ||72 ratio_divide<Period2, period>::type::den == 173 >::type* = 0);74 75 // observer76 77 constexpr rep count() const;78 79 // arithmetic80 81 constexpr common_type<duration>::type operator+() const;82 constexpr common_type<duration>::type operator-() const;83 constexpr duration& operator++(); // constexpr in C++1784 constexpr duration operator++(int); // constexpr in C++1785 constexpr duration& operator--(); // constexpr in C++1786 constexpr duration operator--(int); // constexpr in C++1787 88 constexpr duration& operator+=(const duration& d); // constexpr in C++1789 constexpr duration& operator-=(const duration& d); // constexpr in C++1790 91 duration& operator*=(const rep& rhs); // constexpr in C++1792 duration& operator/=(const rep& rhs); // constexpr in C++1793 duration& operator%=(const rep& rhs); // constexpr in C++1794 duration& operator%=(const duration& rhs); // constexpr in C++1795 96 // special values97 98 static constexpr duration zero(); // noexcept in C++2099 static constexpr duration min(); // noexcept in C++20100 static constexpr duration max(); // noexcept in C++20101};102 103typedef duration<long long, nano> nanoseconds;104typedef duration<long long, micro> microseconds;105typedef duration<long long, milli> milliseconds;106typedef duration<long long > seconds;107typedef duration< long, ratio< 60> > minutes;108typedef duration< long, ratio<3600> > hours;109 110template <class Clock, class Duration = typename Clock::duration>111class time_point112{113public:114 typedef Clock clock;115 typedef Duration duration;116 typedef typename duration::rep rep;117 typedef typename duration::period period;118private:119 duration d_; // exposition only120 121public:122 time_point(); // has value "epoch" // constexpr in C++14123 explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14124 125 // conversions126 template <class Duration2>127 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14128 129 // observer130 131 duration time_since_epoch() const; // constexpr in C++14132 133 // arithmetic134 135 constexpr time_point& operator++(); // C++20136 constexpr time_point operator++(int); // C++20137 constexpr time_point& operator--(); // C++20138 constexpr time_point operator--(int); // C++20139 140 time_point& operator+=(const duration& d); // constexpr in C++17141 time_point& operator-=(const duration& d); // constexpr in C++17142 143 // special values144 145 static constexpr time_point min(); // noexcept in C++20146 static constexpr time_point max(); // noexcept in C++20147};148 149} // chrono150 151// common_type traits152template <class Rep1, class Period1, class Rep2, class Period2>153 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;154 155template <class Clock, class Duration1, class Duration2>156 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;157 158namespace chrono {159 160// duration arithmetic161template <class Rep1, class Period1, class Rep2, class Period2>162 constexpr163 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type164 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);165template <class Rep1, class Period1, class Rep2, class Period2>166 constexpr167 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type168 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);169template <class Rep1, class Period, class Rep2>170 constexpr171 duration<typename common_type<Rep1, Rep2>::type, Period>172 operator*(const duration<Rep1, Period>& d, const Rep2& s);173template <class Rep1, class Period, class Rep2>174 constexpr175 duration<typename common_type<Rep1, Rep2>::type, Period>176 operator*(const Rep1& s, const duration<Rep2, Period>& d);177template <class Rep1, class Period, class Rep2>178 constexpr179 duration<typename common_type<Rep1, Rep2>::type, Period>180 operator/(const duration<Rep1, Period>& d, const Rep2& s);181template <class Rep1, class Period1, class Rep2, class Period2>182 constexpr183 typename common_type<Rep1, Rep2>::type184 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);185 186// duration comparisons187template <class Rep1, class Period1, class Rep2, class Period2>188 constexpr189 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);190template <class Rep1, class Period1, class Rep2, class Period2>191 constexpr192 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); // removed in C++20193template <class Rep1, class Period1, class Rep2, class Period2>194 constexpr195 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);196template <class Rep1, class Period1, class Rep2, class Period2>197 constexpr198 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);199template <class Rep1, class Period1, class Rep2, class Period2>200 constexpr201 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);202template <class Rep1, class Period1, class Rep2, class Period2>203 constexpr204 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);205template<class Rep1, class Period1, class Rep2, class Period2>206 requires three_way_comparable<typename CT::rep>207 constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,208 const duration<Rep2, Period2>& rhs); // since C++20209 210// duration_cast211template <class ToDuration, class Rep, class Period>212 ToDuration duration_cast(const duration<Rep, Period>& d);213 214template <class ToDuration, class Rep, class Period>215 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17216template <class ToDuration, class Rep, class Period>217 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17218template <class ToDuration, class Rep, class Period>219 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17220 221template <class T> struct is_clock; // C++20222template <class T> inline constexpr bool is_clock_v = is_clock<T>::value; // C++20223 224// duration I/O225template<class charT, class traits, class Rep, class Period> // C++20226 basic_ostream<charT, traits>&227 operator<<(basic_ostream<charT, traits>& os,228 const duration<Rep, Period>& d);229 230// time_point arithmetic (all constexpr in C++14)231template <class Clock, class Duration1, class Rep2, class Period2>232 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>233 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);234template <class Rep1, class Period1, class Clock, class Duration2>235 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>236 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);237template <class Clock, class Duration1, class Rep2, class Period2>238 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>239 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);240template <class Clock, class Duration1, class Duration2>241 typename common_type<Duration1, Duration2>::type242 operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);243 244// time_point comparisons (all constexpr in C++14)245template <class Clock, class Duration1, class Duration2>246 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);247template <class Clock, class Duration1, class Duration2>248 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // removed in C++20249template <class Clock, class Duration1, class Duration2>250 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);251template <class Clock, class Duration1, class Duration2>252 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);253template <class Clock, class Duration1, class Duration2>254 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);255template <class Clock, class Duration1, class Duration2>256 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);257template<class Clock, class Duration1,258 three_way_comparable_with<Duration1> Duration2>259 constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,260 const time_point<Clock, Duration2>& rhs); // since C++20261 262// time_point_cast (constexpr in C++14)263 264template <class ToDuration, class Clock, class Duration>265 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);266 267template <class ToDuration, class Clock, class Duration>268 constexpr time_point<Clock, ToDuration>269 floor(const time_point<Clock, Duration>& tp); // C++17270 271template <class ToDuration, class Clock, class Duration>272 constexpr time_point<Clock, ToDuration>273 ceil(const time_point<Clock, Duration>& tp); // C++17274 275template <class ToDuration, class Clock, class Duration>276 constexpr time_point<Clock, ToDuration>277 round(const time_point<Clock, Duration>& tp); // C++17278 279template <class Rep, class Period>280 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17281 282// Clocks283 284class system_clock285{286public:287 typedef microseconds duration;288 typedef duration::rep rep;289 typedef duration::period period;290 typedef chrono::time_point<system_clock> time_point;291 static const bool is_steady = false; // constexpr in C++14292 293 static time_point now() noexcept;294 static time_t to_time_t (const time_point& __t) noexcept;295 static time_point from_time_t(time_t __t) noexcept;296};297 298template <class Duration>299 using sys_time = time_point<system_clock, Duration>; // C++20300using sys_seconds = sys_time<seconds>; // C++20301using sys_days = sys_time<days>; // C++20302 303template<class charT, class traits, class Duration> // C++20304 basic_ostream<charT, traits>&305 operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);306 307template<class charT, class traits> // C++20308 basic_ostream<charT, traits>&309 operator<<(basic_ostream<charT, traits>& os, const sys_days& dp);310 311// [time.clock.utc], class utc_clock312class utc_clock { // C++20313public:314 using rep = a signed arithmetic type;315 using period = ratio<unspecified, unspecified>;316 using duration = chrono::duration<rep, period>;317 using time_point = chrono::time_point<utc_clock>;318 static constexpr bool is_steady = unspecified;319 320 static time_point now();321 322 template<class Duration>323 static sys_time<common_type_t<Duration, seconds>>324 to_sys(const utc_time<Duration>& t);325 template<class Duration>326 static utc_time<common_type_t<Duration, seconds>>327 from_sys(const sys_time<Duration>& t);328};329 330template<class Duration>331using utc_time = time_point<utc_clock, Duration>; // C++20332using utc_seconds = utc_time<seconds>; // C++20333 334template<class charT, class traits, class Duration> // C++20335 basic_ostream<charT, traits>&336 operator<<(basic_ostream<charT, traits>& os, const utc_time<Duration>& t);337 338struct leap_second_info { // C++20339 bool is_leap_second;340 seconds elapsed;341};342 343template<class Duration> // C++20344 leap_second_info get_leap_second_info(const utc_time<Duration>& ut);345 346 347// [time.clock.tai], class tai_clock348class tai_clock { // C++20349public:350 using rep = a signed arithmetic type;351 using period = ratio<unspecified, unspecified>;352 using duration = chrono::duration<rep, period>;353 using time_point = chrono::time_point<tai_clock>;354 static constexpr bool is_steady = unspecified;355 356 static time_point now();357 358 template<class Duration>359 static utc_time<common_type_t<Duration, seconds>>360 to_utc(const tai_time<Duration>& t);361 template<class Duration>362 static tai_time<common_type_t<Duration, seconds>>363 from_utc(const utc_time<Duration>& t);364};365 366template<class Duration>367using tai_time = time_point<tai_clock, Duration>; // C++20368using tai_seconds = tai_time<seconds>; // C++20369 370template<class charT, class traits, class Duration> // C++20371 basic_ostream<charT, traits>&372 operator<<(basic_ostream<charT, traits>& os, const tai_time<Duration>& t);373 374// [time.clock.gps], class gps_clock375class gps_clock { // C++20376public:377 using rep = a signed arithmetic type;378 using period = ratio<unspecified, unspecified>;379 using duration = chrono::duration<rep, period>;380 using time_point = chrono::time_point<gps_clock>;381 static constexpr bool is_steady = unspecified;382 383 static time_point now();384 385 template<class Duration>386 static utc_time<common_type_t<Duration, seconds>>387 to_utc(const gps_time<Duration>& t);388 template<class Duration>389 static gps_time<common_type_t<Duration, seconds>>390 from_utc(const utc_time<Duration>& t);391};392 393template<class Duration>394using gps_time = time_point<gps_clock, Duration>; // C++20395using gps_seconds = gps_time<seconds>; // C++20396 397template<class charT, class traits, class Duration> // C++20398 basic_ostream<charT, traits>&399 operator<<(basic_ostream<charT, traits>& os, const gps_time<Duration>& t);400 401class file_clock // C++20402{403public:404 typedef see-below rep;405 typedef nano period;406 typedef chrono::duration<rep, period> duration;407 typedef chrono::time_point<file_clock> time_point;408 static constexpr bool is_steady = false;409 410 static time_point now() noexcept;411 412 template<class Duration>413 static sys_time<see-below> to_sys(const file_time<Duration>&);414 415 template<class Duration>416 static file_time<see-below> from_sys(const sys_time<Duration>&);417};418 419template<class Duration>420 using file_time = time_point<file_clock, Duration>; // C++20421 422template<class charT, class traits, class Duration> // C++20423 basic_ostream<charT, traits>&424 operator<<(basic_ostream<charT, traits>& os, const file_time<Duration>& tp);425 426class steady_clock427{428public:429 typedef nanoseconds duration;430 typedef duration::rep rep;431 typedef duration::period period;432 typedef chrono::time_point<steady_clock, duration> time_point;433 static const bool is_steady = true; // constexpr in C++14434 435 static time_point now() noexcept;436};437 438typedef steady_clock high_resolution_clock;439 440// [time.clock.local] local time // C++20441struct local_t {};442template<class Duration>443 using local_time = time_point<local_t, Duration>;444using local_seconds = local_time<seconds>;445using local_days = local_time<days>;446 447template<class charT, class traits, class Duration> // C++20448 basic_ostream<charT, traits>&449 operator<<(basic_ostream<charT, traits>& os, const local_time<Duration>& tp);450 451// [time.cal.last] class last_spec // C++20452struct last_spec;453 454// [time.cal.day] class day // C++20455 456class day;457constexpr bool operator==(const day& x, const day& y) noexcept;458constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;459constexpr day operator+(const day& x, const days& y) noexcept;460constexpr day operator+(const days& x, const day& y) noexcept;461constexpr day operator-(const day& x, const days& y) noexcept;462constexpr days operator-(const day& x, const day& y) noexcept;463template<class charT, class traits>464 basic_ostream<charT, traits>&465 operator<<(basic_ostream<charT, traits>& os, const day& d);466 467// [time.cal.month] class month // C++20468class month;469constexpr bool operator==(const month& x, const month& y) noexcept;470constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;471 472constexpr month operator+(const month& x, const months& y) noexcept;473constexpr month operator+(const months& x, const month& y) noexcept;474constexpr month operator-(const month& x, const months& y) noexcept;475constexpr months operator-(const month& x, const month& y) noexcept;476template<class charT, class traits>477 basic_ostream<charT, traits>&478 operator<<(basic_ostream<charT, traits>& os, const month& m);479 480// [time.cal.year] class year // C++20481class year;482constexpr bool operator==(const year& x, const year& y) noexcept;483constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;484 485constexpr year operator+(const year& x, const years& y) noexcept;486constexpr year operator+(const years& x, const year& y) noexcept;487constexpr year operator-(const year& x, const years& y) noexcept;488constexpr years operator-(const year& x, const year& y) noexcept;489template<class charT, class traits>490 basic_ostream<charT, traits>&491 operator<<(basic_ostream<charT, traits>& os, const year& y);492 493// [time.cal.wd] class weekday // C++20494class weekday;495 496constexpr bool operator==(const weekday& x, const weekday& y) noexcept;497constexpr weekday operator+(const weekday& x, const days& y) noexcept;498constexpr weekday operator+(const days& x, const weekday& y) noexcept;499constexpr weekday operator-(const weekday& x, const days& y) noexcept;500constexpr days operator-(const weekday& x, const weekday& y) noexcept;501template<class charT, class traits>502 basic_ostream<charT, traits>&503 operator<<(basic_ostream<charT, traits>& os, const weekday& wd);504 505// [time.cal.wdidx] class weekday_indexed // C++20506 507class weekday_indexed;508constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;509 510template<class charT, class traits>511 basic_ostream<charT, traits>&512 operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);513 514// [time.cal.wdlast] class weekday_last // C++20515class weekday_last;516 517constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;518 519template<class charT, class traits>520 basic_ostream<charT, traits>&521 operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);522 523// [time.cal.md] class month_day // C++20524class month_day;525 526constexpr bool operator==(const month_day& x, const month_day& y) noexcept;527constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;528 529template<class charT, class traits>530 basic_ostream<charT, traits>&531 operator<<(basic_ostream<charT, traits>& os, const month_day& md);532 533// [time.cal.mdlast] class month_day_last // C++20534class month_day_last;535 536constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;537constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;538 539template<class charT, class traits>540 basic_ostream<charT, traits>&541 operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);542 543// [time.cal.mwd] class month_weekday // C++20544class month_weekday;545 546constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;547 548template<class charT, class traits>549 basic_ostream<charT, traits>&550 operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);551 552// [time.cal.mwdlast] class month_weekday_last // C++20553class month_weekday_last;554 555constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;556 557template<class charT, class traits>558 basic_ostream<charT, traits>&559 operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mwdl);560 561 562// [time.cal.ym] class year_month // C++20563class year_month;564 565constexpr bool operator==(const year_month& x, const year_month& y) noexcept;566constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;567 568constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;569constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;570constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;571constexpr months operator-(const year_month& x, const year_month& y) noexcept;572constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;573constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;574constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;575 576template<class charT, class traits>577 basic_ostream<charT, traits>&578 operator<<(basic_ostream<charT, traits>& os, const year_month& ym);579 580// [time.cal.ymd] class year_month_day class // C++20581year_month_day;582 583constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;584constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;585 586constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;587constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;588constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;589constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;590constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;591constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;592 593template<class charT, class traits>594 basic_ostream<charT, traits>&595 operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);596 597// [time.cal.ymdlast] class year_month_day_last // C++20598class year_month_day_last;599 600constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;601constexpr strong_ordering operator<=>(const year_month_day_last_day& x, const year_month_day_last_day& y) noexcept;602 603constexpr year_month_day_last604 operator+(const year_month_day_last& ymdl, const months& dm) noexcept;605constexpr year_month_day_last606 operator+(const months& dm, const year_month_day_last& ymdl) noexcept;607constexpr year_month_day_last608 operator+(const year_month_day_last& ymdl, const years& dy) noexcept;609constexpr year_month_day_last610 operator+(const years& dy, const year_month_day_last& ymdl) noexcept;611constexpr year_month_day_last612 operator-(const year_month_day_last& ymdl, const months& dm) noexcept;613constexpr year_month_day_last614 operator-(const year_month_day_last& ymdl, const years& dy) noexcept;615 616template<class charT, class traits>617 basic_ostream<charT, traits>&618 operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);619 620// [time.cal.ymwd] class year_month_weekday // C++20621class year_month_weekday;622 623constexpr bool operator==(const year_month_weekday& x,624 const year_month_weekday& y) noexcept;625 626constexpr year_month_weekday627 operator+(const year_month_weekday& ymwd, const months& dm) noexcept;628constexpr year_month_weekday629 operator+(const months& dm, const year_month_weekday& ymwd) noexcept;630constexpr year_month_weekday631 operator+(const year_month_weekday& ymwd, const years& dy) noexcept;632constexpr year_month_weekday633 operator+(const years& dy, const year_month_weekday& ymwd) noexcept;634constexpr year_month_weekday635 operator-(const year_month_weekday& ymwd, const months& dm) noexcept;636constexpr year_month_weekday637 operator-(const year_month_weekday& ymwd, const years& dy) noexcept;638 639template<class charT, class traits>640 basic_ostream<charT, traits>&641 operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);642 643// [time.cal.ymwdlast] class year_month_weekday_last // C++20644class year_month_weekday_last;645 646constexpr bool operator==(const year_month_weekday_last& x,647 const year_month_weekday_last& y) noexcept;648constexpr year_month_weekday_last649 operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;650constexpr year_month_weekday_last651 operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;652constexpr year_month_weekday_last653 operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;654constexpr year_month_weekday_last655 operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;656constexpr year_month_weekday_last657 operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;658constexpr year_month_weekday_last659 operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;660 661template<class charT, class traits>662 basic_ostream<charT, traits>&663 operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);664 665// [time.cal.operators] civil calendar conventional syntax operators // C++20666constexpr year_month667 operator/(const year& y, const month& m) noexcept;668constexpr year_month669 operator/(const year& y, int m) noexcept;670constexpr month_day671 operator/(const month& m, const day& d) noexcept;672constexpr month_day673 operator/(const month& m, int d) noexcept;674constexpr month_day675 operator/(int m, const day& d) noexcept;676constexpr month_day677 operator/(const day& d, const month& m) noexcept;678constexpr month_day679 operator/(const day& d, int m) noexcept;680constexpr month_day_last681 operator/(const month& m, last_spec) noexcept;682constexpr month_day_last683 operator/(int m, last_spec) noexcept;684constexpr month_day_last685 operator/(last_spec, const month& m) noexcept;686constexpr month_day_last687 operator/(last_spec, int m) noexcept;688constexpr month_weekday689 operator/(const month& m, const weekday_indexed& wdi) noexcept;690constexpr month_weekday691 operator/(int m, const weekday_indexed& wdi) noexcept;692constexpr month_weekday693 operator/(const weekday_indexed& wdi, const month& m) noexcept;694constexpr month_weekday695 operator/(const weekday_indexed& wdi, int m) noexcept;696constexpr month_weekday_last697 operator/(const month& m, const weekday_last& wdl) noexcept;698constexpr month_weekday_last699 operator/(int m, const weekday_last& wdl) noexcept;700constexpr month_weekday_last701 operator/(const weekday_last& wdl, const month& m) noexcept;702constexpr month_weekday_last703 operator/(const weekday_last& wdl, int m) noexcept;704constexpr year_month_day705 operator/(const year_month& ym, const day& d) noexcept;706constexpr year_month_day707 operator/(const year_month& ym, int d) noexcept;708constexpr year_month_day709 operator/(const year& y, const month_day& md) noexcept;710constexpr year_month_day711 operator/(int y, const month_day& md) noexcept;712constexpr year_month_day713 operator/(const month_day& md, const year& y) noexcept;714constexpr year_month_day715 operator/(const month_day& md, int y) noexcept;716constexpr year_month_day_last717 operator/(const year_month& ym, last_spec) noexcept;718constexpr year_month_day_last719 operator/(const year& y, const month_day_last& mdl) noexcept;720constexpr year_month_day_last721 operator/(int y, const month_day_last& mdl) noexcept;722constexpr year_month_day_last723 operator/(const month_day_last& mdl, const year& y) noexcept;724constexpr year_month_day_last725 operator/(const month_day_last& mdl, int y) noexcept;726constexpr year_month_weekday727 operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;728constexpr year_month_weekday729 operator/(const year& y, const month_weekday& mwd) noexcept;730constexpr year_month_weekday731 operator/(int y, const month_weekday& mwd) noexcept;732constexpr year_month_weekday733 operator/(const month_weekday& mwd, const year& y) noexcept;734constexpr year_month_weekday735 operator/(const month_weekday& mwd, int y) noexcept;736constexpr year_month_weekday_last737 operator/(const year_month& ym, const weekday_last& wdl) noexcept;738constexpr year_month_weekday_last739 operator/(const year& y, const month_weekday_last& mwdl) noexcept;740constexpr year_month_weekday_last741 operator/(int y, const month_weekday_last& mwdl) noexcept;742constexpr year_month_weekday_last743 operator/(const month_weekday_last& mwdl, const year& y) noexcept;744constexpr year_month_weekday_last745 operator/(const month_weekday_last& mwdl, int y) noexcept;746 747// 26.9, class template hh_mm_ss748template <class Duration>749class hh_mm_ss750{751 bool is_neg; // exposition only752 chrono::hours h; // exposition only753 chrono::minutes m; // exposition only754 chrono::seconds s; // exposition only755 precision ss; // exposition only756 757public:758 static unsigned constexpr fractional_width = see below;759 using precision = see below;760 761 constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}762 constexpr explicit hh_mm_ss(Duration d) noexcept;763 764 constexpr bool is_negative() const noexcept;765 constexpr chrono::hours hours() const noexcept;766 constexpr chrono::minutes minutes() const noexcept;767 constexpr chrono::seconds seconds() const noexcept;768 constexpr precision subseconds() const noexcept;769 770 constexpr explicit operator precision() const noexcept;771 constexpr precision to_duration() const noexcept;772};773 774template<class charT, class traits, class Duration>775 basic_ostream<charT, traits>&776 operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms); // C++20777 778// 26.10, 12/24 hour functions779constexpr bool is_am(hours const& h) noexcept;780constexpr bool is_pm(hours const& h) noexcept;781constexpr hours make12(const hours& h) noexcept;782constexpr hours make24(const hours& h, bool is_pm) noexcept;783 784// [time.zone.db], time zone database785struct tzdb { // C++20786 string version;787 vector<time_zone> zones;788 vector<time_zone_link> links;789 vector<leap_second> leap_seconds;790 791 const time_zone* locate_zone(string_view tz_name) const;792 const time_zone* current_zone() const;793};794 795class tzdb_list { // C++20796public:797 tzdb_list(const tzdb_list&) = delete;798 tzdb_list& operator=(const tzdb_list&) = delete;799 800 // unspecified additional constructors801 802 class const_iterator;803 804 const tzdb& front() const noexcept;805 806 const_iterator erase_after(const_iterator p);807 808 const_iterator begin() const noexcept;809 const_iterator end() const noexcept;810 811 const_iterator cbegin() const noexcept;812 const_iterator cend() const noexcept;813};814 815// [time.zone.db.access], time zone database access816const tzdb& get_tzdb(); // C++20817tzdb_list& get_tzdb_list(); // C++20818const time_zone* locate_zone(string_view tz_name); // C++20819const time_zone* current_zone() // C++20820 821// [time.zone.db.remote], remote time zone database support822const tzdb& reload_tzdb(); // C++20823string remote_version(); // C++20824 825// [time.zone.exception], exception classes826class nonexistent_local_time; // C++20827class ambiguous_local_time; // C++20828 829// [time.zone.info], information classes830struct sys_info { // C++20831 sys_seconds begin;832 sys_seconds end;833 seconds offset;834 minutes save;835 string abbrev;836};837 838template<class charT, class traits> // C++20839 basic_ostream<charT, traits>&840 operator<<(basic_ostream<charT, traits>& os, const sys_info& si);841 842struct local_info { // C++20843 static constexpr int unique = 0;844 static constexpr int nonexistent = 1;845 static constexpr int ambiguous = 2;846 847 int result;848 sys_info first;849 sys_info second;850};851 852template<class charT, class traits> // C++20853 basic_ostream<charT, traits>&854 operator<<(basic_ostream<charT, traits>& os, const local_info& li);855 856// [time.zone.timezone] class time_zone // C++20857enum class choose {earliest, latest};858class time_zone {859 time_zone(time_zone&&) = default;860 time_zone& operator=(time_zone&&) = default;861 862 // unspecified additional constructors863 864 string_view name() const noexcept;865 866 template<class Duration>867 sys_info get_info(const sys_time<Duration>& st) const;868 869 template<class Duration>870 local_info get_info(const local_time<Duration>& tp) const;871 872 template<class Duration>873 sys_time<common_type_t<Duration, seconds>>874 to_sys(const local_time<Duration>& tp) const;875 876 template<class Duration>877 sys_time<common_type_t<Duration, seconds>>878 to_sys(const local_time<Duration>& tp, choose z) const;879 880 template<class Duration>881 local_time<common_type_t<Duration, seconds>>882 to_local(const sys_time<Duration>& tp) const;883};884bool operator==(const time_zone& x, const time_zone& y) noexcept; // C++20885strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept; // C++20886 887// [time.zone.zonedtraits], class template zoned_traits888template<class T> struct zoned_traits; // C++20889 890// [time.zone.zonedtime], class template zoned_time891template<class Duration, class TimeZonePtr = const time_zone*> // C++20892class zoned_time;893 894using zoned_seconds = zoned_time<seconds>; // C++20895 896template<class Duration1, class Duration2, class TimeZonePtr> // C++20897 bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,898 const zoned_time<Duration2, TimeZonePtr>& y);899 900template<class charT, class traits, class Duration, class TimeZonePtr> // C++20901 basic_ostream<charT, traits>&902 operator<<(basic_ostream<charT, traits>& os,903 const zoned_time<Duration, TimeZonePtr>& t);904 905// [time.zone.leap], leap second support906class leap_second { // C++20907public:908 leap_second(const leap_second&) = default;909 leap_second& operator=(const leap_second&) = default;910 911 // unspecified additional constructors912 913 constexpr sys_seconds date() const noexcept;914 constexpr seconds value() const noexcept;915};916 917constexpr bool operator==(const leap_second& x, const leap_second& y); // C++20918constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y);919 920template<class Duration> // C++20921 constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);922template<class Duration> // C++20923 constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);924template<class Duration> // C++20925 constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);926template<class Duration> // C++20927 constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);928template<class Duration> // C++20929 constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);930template<class Duration> // C++20931 constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);932template<class Duration> // C++20933 constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);934template<class Duration> // C++20935 constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);936template<class Duration> // C++20937 constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);938template<class Duration> // C++20939 requires three_way_comparable_with<sys_seconds, sys_time<Duration>>940 constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);941 942// [time.zone.link], class time_zone_link943class time_zone_link { // C++20944public:945 time_zone_link(time_zone_link&&) = default;946 time_zone_link& operator=(time_zone_link&&) = default;947 948 // unspecified additional constructors949 950 string_view name() const noexcept;951 string_view target() const noexcept;952};953 954bool operator==(const time_zone_link& x, const time_zone_link& y); // C++20955strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y); // C++20956 957} // chrono958 959namespace std {960 template<class Rep, class Period, class charT>961 struct formatter<chrono::duration<Rep, Period>, charT>; // C++20962 template<class Duration, class charT>963 struct formatter<chrono::sys_time<Duration>, charT>; // C++20964 template<class Duration, class charT>965 struct formatter<chrono::utc_time<Duration>, charT>; // C++20966 template<class Duration, class charT>967 struct formatter<chrono::tai_time<Duration>, charT>; // C++20968 template<class Duration, class charT>969 struct formatter<chrono::gps_time<Duration>, charT>; // C++20970 template<class Duration, class charT>971 struct formatter<chrono::file_time<Duration>, charT>; // C++20972 template<class Duration, class charT>973 struct formatter<chrono::local_time<Duration>, charT>; // C++20974 template<class charT> struct formatter<chrono::day, charT>; // C++20975 template<class charT> struct formatter<chrono::month, charT>; // C++20976 template<class charT> struct formatter<chrono::year, charT>; // C++20977 template<class charT> struct formatter<chrono::weekday, charT>; // C++20978 template<class charT> struct formatter<chrono::weekday_indexed, charT>; // C++20979 template<class charT> struct formatter<chrono::weekday_last, charT>; // C++20980 template<class charT> struct formatter<chrono::month_day, charT>; // C++20981 template<class charT> struct formatter<chrono::month_day_last, charT>; // C++20982 template<class charT> struct formatter<chrono::month_weekday, charT>; // C++20983 template<class charT> struct formatter<chrono::month_weekday_last, charT>; // C++20984 template<class charT> struct formatter<chrono::year_month, charT>; // C++20985 template<class charT> struct formatter<chrono::year_month_day, charT>; // C++20986 template<class charT> struct formatter<chrono::year_month_day_last, charT>; // C++20987 template<class charT> struct formatter<chrono::year_month_weekday, charT>; // C++20988 template<class charT> struct formatter<chrono::year_month_weekday_last, charT>; // C++20989 template<class Rep, class Period, class charT>990 struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>; // C++20991 template<class charT> struct formatter<chrono::sys_info, charT>; // C++20992 template<class charT> struct formatter<chrono::local_info, charT>; // C++20993 template<class Duration, class TimeZonePtr, class charT> // C++20994 struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;995} // namespace std996 997namespace chrono {998// calendrical constants999inline constexpr last_spec last{}; // C++201000inline constexpr chrono::weekday Sunday{0}; // C++201001inline constexpr chrono::weekday Monday{1}; // C++201002inline constexpr chrono::weekday Tuesday{2}; // C++201003inline constexpr chrono::weekday Wednesday{3}; // C++201004inline constexpr chrono::weekday Thursday{4}; // C++201005inline constexpr chrono::weekday Friday{5}; // C++201006inline constexpr chrono::weekday Saturday{6}; // C++201007 1008inline constexpr chrono::month January{1}; // C++201009inline constexpr chrono::month February{2}; // C++201010inline constexpr chrono::month March{3}; // C++201011inline constexpr chrono::month April{4}; // C++201012inline constexpr chrono::month May{5}; // C++201013inline constexpr chrono::month June{6}; // C++201014inline constexpr chrono::month July{7}; // C++201015inline constexpr chrono::month August{8}; // C++201016inline constexpr chrono::month September{9}; // C++201017inline constexpr chrono::month October{10}; // C++201018inline constexpr chrono::month November{11}; // C++201019inline constexpr chrono::month December{12}; // C++201020} // chrono1021 1022inline namespace literals {1023 inline namespace chrono_literals {1024constexpr chrono::hours operator ""h(unsigned long long); // C++141025constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++141026constexpr chrono::minutes operator ""min(unsigned long long); // C++141027constexpr chrono::duration<unspecified , ratio<60,1>> operator ""min(long double); // C++141028constexpr chrono::seconds operator ""s(unsigned long long); // C++141029constexpr chrono::duration<unspecified > operator ""s(long double); // C++141030constexpr chrono::milliseconds operator ""ms(unsigned long long); // C++141031constexpr chrono::duration<unspecified , milli> operator ""ms(long double); // C++141032constexpr chrono::microseconds operator ""us(unsigned long long); // C++141033constexpr chrono::duration<unspecified , micro> operator ""us(long double); // C++141034constexpr chrono::nanoseconds operator ""ns(unsigned long long); // C++141035constexpr chrono::duration<unspecified , nano> operator ""ns(long double); // C++141036constexpr chrono::day operator ""d(unsigned long long d) noexcept; // C++201037constexpr chrono::year operator ""y(unsigned long long y) noexcept; // C++201038} // chrono_literals1039} // literals1040 1041} // std1042*/1043 1044// clang-format on1045 1046#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)1047# include <__cxx03/chrono>1048#else1049# include <__config>1050 1051# include <__chrono/duration.h>1052# include <__chrono/file_clock.h>1053# include <__chrono/high_resolution_clock.h>1054# include <__chrono/steady_clock.h>1055# include <__chrono/system_clock.h>1056# include <__chrono/time_point.h>1057 1058# if _LIBCPP_STD_VER >= 201059# include <__chrono/calendar.h>1060# include <__chrono/day.h>1061# include <__chrono/exception.h>1062# include <__chrono/hh_mm_ss.h>1063# include <__chrono/is_clock.h>1064# include <__chrono/literals.h>1065# include <__chrono/local_info.h>1066# include <__chrono/month.h>1067# include <__chrono/month_weekday.h>1068# include <__chrono/monthday.h>1069# include <__chrono/sys_info.h>1070# include <__chrono/weekday.h>1071# include <__chrono/year.h>1072# include <__chrono/year_month.h>1073# include <__chrono/year_month_day.h>1074# include <__chrono/year_month_weekday.h>1075 1076# if _LIBCPP_HAS_LOCALIZATION1077# include <__chrono/formatter.h>1078# include <__chrono/ostream.h>1079# include <__chrono/parser_std_format_spec.h>1080# include <__chrono/statically_widen.h>1081# endif1082 1083# if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION1084# include <__chrono/gps_clock.h>1085# include <__chrono/leap_second.h>1086# include <__chrono/tai_clock.h>1087# include <__chrono/time_zone.h>1088# include <__chrono/time_zone_link.h>1089# include <__chrono/tzdb.h>1090# include <__chrono/tzdb_list.h>1091# include <__chrono/utc_clock.h>1092# include <__chrono/zoned_time.h>1093# endif1094 1095# endif1096 1097# include <version>1098 1099// standard-mandated includes1100 1101// [time.syn]1102# include <compare>1103 1104# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)1105# pragma GCC system_header1106# endif1107 1108# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 171109# include <cstdint>1110# include <stdexcept>1111# include <string_view>1112# endif1113 1114# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 201115# include <bit>1116# include <concepts>1117# include <cstring>1118# include <forward_list>1119# include <string>1120# include <tuple>1121# include <vector>1122# endif1123 1124# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 201125# include <charconv>1126# if _LIBCPP_HAS_LOCALIZATION1127# include <locale>1128# include <ostream>1129# endif1130# endif1131#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)1132 1133#endif // _LIBCPP_CHRONO1134