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