Warning, /include/c++/v1/chrono is written in an unsupported language. File is not indexed.
0001 // -*- C++ -*-
0002 //===----------------------------------------------------------------------===//
0003 //
0004 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0005 // See https://llvm.org/LICENSE.txt for license information.
0006 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0007 //
0008 //===----------------------------------------------------------------------===//
0009
0010 #ifndef _LIBCPP_CHRONO
0011 #define _LIBCPP_CHRONO
0012
0013 // clang-format off
0014
0015 /*
0016 chrono synopsis
0017
0018 #include <compare> // C++20
0019
0020 namespace std
0021 {
0022 namespace chrono
0023 {
0024
0025 template <class ToDuration, class Rep, class Period>
0026 constexpr
0027 ToDuration
0028 duration_cast(const duration<Rep, Period>& fd);
0029
0030 template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
0031
0032 template <class Rep> inline constexpr bool treat_as_floating_point_v
0033 = treat_as_floating_point<Rep>::value; // C++17
0034
0035 template <class Rep>
0036 struct duration_values
0037 {
0038 public:
0039 static constexpr Rep zero(); // noexcept in C++20
0040 static constexpr Rep max(); // noexcept in C++20
0041 static constexpr Rep min(); // noexcept in C++20
0042 };
0043
0044 // duration
0045
0046 template <class Rep, class Period = ratio<1>>
0047 class duration
0048 {
0049 static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
0050 static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
0051 static_assert(Period::num > 0, "duration period must be positive");
0052 public:
0053 typedef Rep rep;
0054 typedef typename _Period::type period;
0055
0056 constexpr duration() = default;
0057 template <class Rep2>
0058 constexpr explicit duration(const Rep2& r,
0059 typename enable_if
0060 <
0061 is_convertible<const Rep2&, rep>::value &&
0062 (treat_as_floating_point<rep>::value ||
0063 !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
0064 >::type* = 0);
0065
0066 // conversions
0067 template <class Rep2, class Period2>
0068 constexpr duration(const duration<Rep2, Period2>& d,
0069 typename enable_if
0070 <
0071 treat_as_floating_point<rep>::value ||
0072 ratio_divide<Period2, period>::type::den == 1
0073 >::type* = 0);
0074
0075 // observer
0076
0077 constexpr rep count() const;
0078
0079 // arithmetic
0080
0081 constexpr common_type<duration>::type operator+() const;
0082 constexpr common_type<duration>::type operator-() const;
0083 constexpr duration& operator++(); // constexpr in C++17
0084 constexpr duration operator++(int); // constexpr in C++17
0085 constexpr duration& operator--(); // constexpr in C++17
0086 constexpr duration operator--(int); // constexpr in C++17
0087
0088 constexpr duration& operator+=(const duration& d); // constexpr in C++17
0089 constexpr duration& operator-=(const duration& d); // constexpr in C++17
0090
0091 duration& operator*=(const rep& rhs); // constexpr in C++17
0092 duration& operator/=(const rep& rhs); // constexpr in C++17
0093 duration& operator%=(const rep& rhs); // constexpr in C++17
0094 duration& operator%=(const duration& rhs); // constexpr in C++17
0095
0096 // special values
0097
0098 static constexpr duration zero(); // noexcept in C++20
0099 static constexpr duration min(); // noexcept in C++20
0100 static constexpr duration max(); // noexcept in C++20
0101 };
0102
0103 typedef duration<long long, nano> nanoseconds;
0104 typedef duration<long long, micro> microseconds;
0105 typedef duration<long long, milli> milliseconds;
0106 typedef duration<long long > seconds;
0107 typedef duration< long, ratio< 60> > minutes;
0108 typedef duration< long, ratio<3600> > hours;
0109
0110 template <class Clock, class Duration = typename Clock::duration>
0111 class time_point
0112 {
0113 public:
0114 typedef Clock clock;
0115 typedef Duration duration;
0116 typedef typename duration::rep rep;
0117 typedef typename duration::period period;
0118 private:
0119 duration d_; // exposition only
0120
0121 public:
0122 time_point(); // has value "epoch" // constexpr in C++14
0123 explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14
0124
0125 // conversions
0126 template <class Duration2>
0127 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14
0128
0129 // observer
0130
0131 duration time_since_epoch() const; // constexpr in C++14
0132
0133 // arithmetic
0134
0135 time_point& operator+=(const duration& d); // constexpr in C++17
0136 time_point& operator-=(const duration& d); // constexpr in C++17
0137
0138 // special values
0139
0140 static constexpr time_point min(); // noexcept in C++20
0141 static constexpr time_point max(); // noexcept in C++20
0142 };
0143
0144 } // chrono
0145
0146 // common_type traits
0147 template <class Rep1, class Period1, class Rep2, class Period2>
0148 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
0149
0150 template <class Clock, class Duration1, class Duration2>
0151 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
0152
0153 namespace chrono {
0154
0155 // duration arithmetic
0156 template <class Rep1, class Period1, class Rep2, class Period2>
0157 constexpr
0158 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
0159 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0160 template <class Rep1, class Period1, class Rep2, class Period2>
0161 constexpr
0162 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
0163 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0164 template <class Rep1, class Period, class Rep2>
0165 constexpr
0166 duration<typename common_type<Rep1, Rep2>::type, Period>
0167 operator*(const duration<Rep1, Period>& d, const Rep2& s);
0168 template <class Rep1, class Period, class Rep2>
0169 constexpr
0170 duration<typename common_type<Rep1, Rep2>::type, Period>
0171 operator*(const Rep1& s, const duration<Rep2, Period>& d);
0172 template <class Rep1, class Period, class Rep2>
0173 constexpr
0174 duration<typename common_type<Rep1, Rep2>::type, Period>
0175 operator/(const duration<Rep1, Period>& d, const Rep2& s);
0176 template <class Rep1, class Period1, class Rep2, class Period2>
0177 constexpr
0178 typename common_type<Rep1, Rep2>::type
0179 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0180
0181 // duration comparisons
0182 template <class Rep1, class Period1, class Rep2, class Period2>
0183 constexpr
0184 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0185 template <class Rep1, class Period1, class Rep2, class Period2>
0186 constexpr
0187 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); // removed in C++20
0188 template <class Rep1, class Period1, class Rep2, class Period2>
0189 constexpr
0190 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0191 template <class Rep1, class Period1, class Rep2, class Period2>
0192 constexpr
0193 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0194 template <class Rep1, class Period1, class Rep2, class Period2>
0195 constexpr
0196 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0197 template <class Rep1, class Period1, class Rep2, class Period2>
0198 constexpr
0199 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
0200 template<class Rep1, class Period1, class Rep2, class Period2>
0201 requires three_way_comparable<typename CT::rep>
0202 constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
0203 const duration<Rep2, Period2>& rhs); // since C++20
0204
0205 // duration_cast
0206 template <class ToDuration, class Rep, class Period>
0207 ToDuration duration_cast(const duration<Rep, Period>& d);
0208
0209 template <class ToDuration, class Rep, class Period>
0210 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17
0211 template <class ToDuration, class Rep, class Period>
0212 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17
0213 template <class ToDuration, class Rep, class Period>
0214 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17
0215
0216 // duration I/O
0217 template<class charT, class traits, class Rep, class Period> // C++20
0218 basic_ostream<charT, traits>&
0219 operator<<(basic_ostream<charT, traits>& os,
0220 const duration<Rep, Period>& d);
0221
0222 // time_point arithmetic (all constexpr in C++14)
0223 template <class Clock, class Duration1, class Rep2, class Period2>
0224 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
0225 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
0226 template <class Rep1, class Period1, class Clock, class Duration2>
0227 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
0228 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
0229 template <class Clock, class Duration1, class Rep2, class Period2>
0230 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
0231 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
0232 template <class Clock, class Duration1, class Duration2>
0233 typename common_type<Duration1, Duration2>::type
0234 operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
0235
0236 // time_point comparisons (all constexpr in C++14)
0237 template <class Clock, class Duration1, class Duration2>
0238 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
0239 template <class Clock, class Duration1, class Duration2>
0240 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs); // removed in C++20
0241 template <class Clock, class Duration1, class Duration2>
0242 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
0243 template <class Clock, class Duration1, class Duration2>
0244 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
0245 template <class Clock, class Duration1, class Duration2>
0246 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
0247 template <class Clock, class Duration1, class Duration2>
0248 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
0249 template<class Clock, class Duration1,
0250 three_way_comparable_with<Duration1> Duration2>
0251 constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
0252 const time_point<Clock, Duration2>& rhs); // since C++20
0253
0254 // time_point_cast (constexpr in C++14)
0255
0256 template <class ToDuration, class Clock, class Duration>
0257 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
0258
0259 template <class ToDuration, class Clock, class Duration>
0260 constexpr time_point<Clock, ToDuration>
0261 floor(const time_point<Clock, Duration>& tp); // C++17
0262
0263 template <class ToDuration, class Clock, class Duration>
0264 constexpr time_point<Clock, ToDuration>
0265 ceil(const time_point<Clock, Duration>& tp); // C++17
0266
0267 template <class ToDuration, class Clock, class Duration>
0268 constexpr time_point<Clock, ToDuration>
0269 round(const time_point<Clock, Duration>& tp); // C++17
0270
0271 template <class Rep, class Period>
0272 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17
0273
0274 // Clocks
0275
0276 class system_clock
0277 {
0278 public:
0279 typedef microseconds duration;
0280 typedef duration::rep rep;
0281 typedef duration::period period;
0282 typedef chrono::time_point<system_clock> time_point;
0283 static const bool is_steady = false; // constexpr in C++14
0284
0285 static time_point now() noexcept;
0286 static time_t to_time_t (const time_point& __t) noexcept;
0287 static time_point from_time_t(time_t __t) noexcept;
0288 };
0289
0290 template <class Duration>
0291 using sys_time = time_point<system_clock, Duration>; // C++20
0292 using sys_seconds = sys_time<seconds>; // C++20
0293 using sys_days = sys_time<days>; // C++20
0294
0295 template<class charT, class traits, class Duration> // C++20
0296 basic_ostream<charT, traits>&
0297 operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);
0298
0299 template<class charT, class traits> // C++20
0300 basic_ostream<charT, traits>&
0301 operator<<(basic_ostream<charT, traits>& os, const sys_days& dp);
0302
0303 // [time.clock.utc], class utc_clock
0304 class utc_clock { // C++20
0305 public:
0306 using rep = a signed arithmetic type;
0307 using period = ratio<unspecified, unspecified>;
0308 using duration = chrono::duration<rep, period>;
0309 using time_point = chrono::time_point<utc_clock>;
0310 static constexpr bool is_steady = unspecified;
0311
0312 static time_point now();
0313
0314 template<class Duration>
0315 static sys_time<common_type_t<Duration, seconds>>
0316 to_sys(const utc_time<Duration>& t);
0317 template<class Duration>
0318 static utc_time<common_type_t<Duration, seconds>>
0319 from_sys(const sys_time<Duration>& t);
0320 };
0321
0322 template<class Duration>
0323 using utc_time = time_point<utc_clock, Duration>; // C++20
0324 using utc_seconds = utc_time<seconds>; // C++20
0325
0326 template<class charT, class traits, class Duration> // C++20
0327 basic_ostream<charT, traits>&
0328 operator<<(basic_ostream<charT, traits>& os, const utc_time<Duration>& t);
0329
0330 struct leap_second_info { // C++20
0331 bool is_leap_second;
0332 seconds elapsed;
0333 };
0334
0335 template<class Duration> // C++20
0336 leap_second_info get_leap_second_info(const utc_time<Duration>& ut);
0337
0338 class file_clock // C++20
0339 {
0340 public:
0341 typedef see-below rep;
0342 typedef nano period;
0343 typedef chrono::duration<rep, period> duration;
0344 typedef chrono::time_point<file_clock> time_point;
0345 static constexpr bool is_steady = false;
0346
0347 static time_point now() noexcept;
0348
0349 template<class Duration>
0350 static sys_time<see-below> to_sys(const file_time<Duration>&);
0351
0352 template<class Duration>
0353 static file_time<see-below> from_sys(const sys_time<Duration>&);
0354 };
0355
0356 template<class Duration>
0357 using file_time = time_point<file_clock, Duration>; // C++20
0358
0359 template<class charT, class traits, class Duration> // C++20
0360 basic_ostream<charT, traits>&
0361 operator<<(basic_ostream<charT, traits>& os, const file_time<Duration>& tp);
0362
0363 class steady_clock
0364 {
0365 public:
0366 typedef nanoseconds duration;
0367 typedef duration::rep rep;
0368 typedef duration::period period;
0369 typedef chrono::time_point<steady_clock, duration> time_point;
0370 static const bool is_steady = true; // constexpr in C++14
0371
0372 static time_point now() noexcept;
0373 };
0374
0375 typedef steady_clock high_resolution_clock;
0376
0377 // 25.7.8, local time // C++20
0378 struct local_t {};
0379 template<class Duration>
0380 using local_time = time_point<local_t, Duration>;
0381 using local_seconds = local_time<seconds>;
0382 using local_days = local_time<days>;
0383
0384 template<class charT, class traits, class Duration> // C++20
0385 basic_ostream<charT, traits>&
0386 operator<<(basic_ostream<charT, traits>& os, const local_time<Duration>& tp);
0387
0388 // 25.8.2, class last_spec // C++20
0389 struct last_spec;
0390
0391 // 25.8.3, class day // C++20
0392
0393 class day;
0394 constexpr bool operator==(const day& x, const day& y) noexcept;
0395 constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
0396 constexpr day operator+(const day& x, const days& y) noexcept;
0397 constexpr day operator+(const days& x, const day& y) noexcept;
0398 constexpr day operator-(const day& x, const days& y) noexcept;
0399 constexpr days operator-(const day& x, const day& y) noexcept;
0400 template<class charT, class traits>
0401 basic_ostream<charT, traits>&
0402 operator<<(basic_ostream<charT, traits>& os, const day& d);
0403
0404 // 25.8.4, class month // C++20
0405 class month;
0406 constexpr bool operator==(const month& x, const month& y) noexcept;
0407 constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
0408
0409 constexpr month operator+(const month& x, const months& y) noexcept;
0410 constexpr month operator+(const months& x, const month& y) noexcept;
0411 constexpr month operator-(const month& x, const months& y) noexcept;
0412 constexpr months operator-(const month& x, const month& y) noexcept;
0413 template<class charT, class traits>
0414 basic_ostream<charT, traits>&
0415 operator<<(basic_ostream<charT, traits>& os, const month& m);
0416
0417 // 25.8.5, class year // C++20
0418 class year;
0419 constexpr bool operator==(const year& x, const year& y) noexcept;
0420 constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
0421
0422 constexpr year operator+(const year& x, const years& y) noexcept;
0423 constexpr year operator+(const years& x, const year& y) noexcept;
0424 constexpr year operator-(const year& x, const years& y) noexcept;
0425 constexpr years operator-(const year& x, const year& y) noexcept;
0426 template<class charT, class traits>
0427 basic_ostream<charT, traits>&
0428 operator<<(basic_ostream<charT, traits>& os, const year& y);
0429
0430 // 25.8.6, class weekday // C++20
0431 class weekday;
0432
0433 constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
0434 constexpr weekday operator+(const weekday& x, const days& y) noexcept;
0435 constexpr weekday operator+(const days& x, const weekday& y) noexcept;
0436 constexpr weekday operator-(const weekday& x, const days& y) noexcept;
0437 constexpr days operator-(const weekday& x, const weekday& y) noexcept;
0438 template<class charT, class traits>
0439 basic_ostream<charT, traits>&
0440 operator<<(basic_ostream<charT, traits>& os, const weekday& wd);
0441
0442 // 25.8.7, class weekday_indexed // C++20
0443
0444 class weekday_indexed;
0445 constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
0446
0447 template<class charT, class traits>
0448 basic_ostream<charT, traits>&
0449 operator<<(basic_ostream<charT, traits>& os, const weekday_indexed& wdi);
0450
0451 // 25.8.8, class weekday_last // C++20
0452 class weekday_last;
0453
0454 constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
0455
0456 template<class charT, class traits>
0457 basic_ostream<charT, traits>&
0458 operator<<(basic_ostream<charT, traits>& os, const weekday_last& wdl);
0459
0460 // 25.8.9, class month_day // C++20
0461 class month_day;
0462
0463 constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
0464 constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
0465
0466 template<class charT, class traits>
0467 basic_ostream<charT, traits>&
0468 operator<<(basic_ostream<charT, traits>& os, const month_day& md);
0469
0470 // 25.8.10, class month_day_last // C++20
0471 class month_day_last;
0472
0473 constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
0474 constexpr strong_ordering operator<=>(const month_day_last& x, const month_day_last& y) noexcept;
0475
0476 template<class charT, class traits>
0477 basic_ostream<charT, traits>&
0478 operator<<(basic_ostream<charT, traits>& os, const month_day_last& mdl);
0479
0480 // 25.8.11, class month_weekday // C++20
0481 class month_weekday;
0482
0483 constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
0484
0485 template<class charT, class traits>
0486 basic_ostream<charT, traits>&
0487 operator<<(basic_ostream<charT, traits>& os, const month_weekday& mwd);
0488
0489 // 25.8.12, class month_weekday_last // C++20
0490 class month_weekday_last;
0491
0492 constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
0493
0494 template<class charT, class traits>
0495 basic_ostream<charT, traits>&
0496 operator<<(basic_ostream<charT, traits>& os, const month_weekday_last& mwdl);
0497
0498
0499 // 25.8.13, class year_month // C++20
0500 class year_month;
0501
0502 constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
0503 constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
0504
0505 constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
0506 constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
0507 constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
0508 constexpr months operator-(const year_month& x, const year_month& y) noexcept;
0509 constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
0510 constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
0511 constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
0512
0513 template<class charT, class traits>
0514 basic_ostream<charT, traits>&
0515 operator<<(basic_ostream<charT, traits>& os, const year_month& ym);
0516
0517 // 25.8.14, class year_month_day class // C++20
0518 year_month_day;
0519
0520 constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
0521 constexpr strong_ordering operator<=>(const year_month_day& x, const year_month_day& y) noexcept;
0522
0523 constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
0524 constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
0525 constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
0526 constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
0527 constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
0528 constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
0529
0530 template<class charT, class traits>
0531 basic_ostream<charT, traits>&
0532 operator<<(basic_ostream<charT, traits>& os, const year_month_day& ymd);
0533
0534 // 25.8.15, class year_month_day_last // C++20
0535 class year_month_day_last;
0536
0537 constexpr bool operator==(const year_month_day_last& x, const year_month_day_last& y) noexcept;
0538 constexpr strong_ordering operator<=>(const year_month_day_last_day& x, const year_month_day_last_day& y) noexcept;
0539
0540 constexpr year_month_day_last
0541 operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
0542 constexpr year_month_day_last
0543 operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
0544 constexpr year_month_day_last
0545 operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
0546 constexpr year_month_day_last
0547 operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
0548 constexpr year_month_day_last
0549 operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
0550 constexpr year_month_day_last
0551 operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
0552
0553 template<class charT, class traits>
0554 basic_ostream<charT, traits>&
0555 operator<<(basic_ostream<charT, traits>& os, const year_month_day_last& ymdl);
0556
0557 // 25.8.16, class year_month_weekday // C++20
0558 class year_month_weekday;
0559
0560 constexpr bool operator==(const year_month_weekday& x,
0561 const year_month_weekday& y) noexcept;
0562
0563 constexpr year_month_weekday
0564 operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
0565 constexpr year_month_weekday
0566 operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
0567 constexpr year_month_weekday
0568 operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
0569 constexpr year_month_weekday
0570 operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
0571 constexpr year_month_weekday
0572 operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
0573 constexpr year_month_weekday
0574 operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
0575
0576 template<class charT, class traits>
0577 basic_ostream<charT, traits>&
0578 operator<<(basic_ostream<charT, traits>& os, const year_month_weekday& ymwd);
0579
0580 // 25.8.17, class year_month_weekday_last // C++20
0581 class year_month_weekday_last;
0582
0583 constexpr bool operator==(const year_month_weekday_last& x,
0584 const year_month_weekday_last& y) noexcept;
0585 constexpr year_month_weekday_last
0586 operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
0587 constexpr year_month_weekday_last
0588 operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
0589 constexpr year_month_weekday_last
0590 operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
0591 constexpr year_month_weekday_last
0592 operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
0593 constexpr year_month_weekday_last
0594 operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
0595 constexpr year_month_weekday_last
0596 operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
0597
0598 template<class charT, class traits>
0599 basic_ostream<charT, traits>&
0600 operator<<(basic_ostream<charT, traits>& os, const year_month_weekday_last& ymwdl);
0601
0602 // 25.8.18, civil calendar conventional syntax operators // C++20
0603 constexpr year_month
0604 operator/(const year& y, const month& m) noexcept;
0605 constexpr year_month
0606 operator/(const year& y, int m) noexcept;
0607 constexpr month_day
0608 operator/(const month& m, const day& d) noexcept;
0609 constexpr month_day
0610 operator/(const month& m, int d) noexcept;
0611 constexpr month_day
0612 operator/(int m, const day& d) noexcept;
0613 constexpr month_day
0614 operator/(const day& d, const month& m) noexcept;
0615 constexpr month_day
0616 operator/(const day& d, int m) noexcept;
0617 constexpr month_day_last
0618 operator/(const month& m, last_spec) noexcept;
0619 constexpr month_day_last
0620 operator/(int m, last_spec) noexcept;
0621 constexpr month_day_last
0622 operator/(last_spec, const month& m) noexcept;
0623 constexpr month_day_last
0624 operator/(last_spec, int m) noexcept;
0625 constexpr month_weekday
0626 operator/(const month& m, const weekday_indexed& wdi) noexcept;
0627 constexpr month_weekday
0628 operator/(int m, const weekday_indexed& wdi) noexcept;
0629 constexpr month_weekday
0630 operator/(const weekday_indexed& wdi, const month& m) noexcept;
0631 constexpr month_weekday
0632 operator/(const weekday_indexed& wdi, int m) noexcept;
0633 constexpr month_weekday_last
0634 operator/(const month& m, const weekday_last& wdl) noexcept;
0635 constexpr month_weekday_last
0636 operator/(int m, const weekday_last& wdl) noexcept;
0637 constexpr month_weekday_last
0638 operator/(const weekday_last& wdl, const month& m) noexcept;
0639 constexpr month_weekday_last
0640 operator/(const weekday_last& wdl, int m) noexcept;
0641 constexpr year_month_day
0642 operator/(const year_month& ym, const day& d) noexcept;
0643 constexpr year_month_day
0644 operator/(const year_month& ym, int d) noexcept;
0645 constexpr year_month_day
0646 operator/(const year& y, const month_day& md) noexcept;
0647 constexpr year_month_day
0648 operator/(int y, const month_day& md) noexcept;
0649 constexpr year_month_day
0650 operator/(const month_day& md, const year& y) noexcept;
0651 constexpr year_month_day
0652 operator/(const month_day& md, int y) noexcept;
0653 constexpr year_month_day_last
0654 operator/(const year_month& ym, last_spec) noexcept;
0655 constexpr year_month_day_last
0656 operator/(const year& y, const month_day_last& mdl) noexcept;
0657 constexpr year_month_day_last
0658 operator/(int y, const month_day_last& mdl) noexcept;
0659 constexpr year_month_day_last
0660 operator/(const month_day_last& mdl, const year& y) noexcept;
0661 constexpr year_month_day_last
0662 operator/(const month_day_last& mdl, int y) noexcept;
0663 constexpr year_month_weekday
0664 operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
0665 constexpr year_month_weekday
0666 operator/(const year& y, const month_weekday& mwd) noexcept;
0667 constexpr year_month_weekday
0668 operator/(int y, const month_weekday& mwd) noexcept;
0669 constexpr year_month_weekday
0670 operator/(const month_weekday& mwd, const year& y) noexcept;
0671 constexpr year_month_weekday
0672 operator/(const month_weekday& mwd, int y) noexcept;
0673 constexpr year_month_weekday_last
0674 operator/(const year_month& ym, const weekday_last& wdl) noexcept;
0675 constexpr year_month_weekday_last
0676 operator/(const year& y, const month_weekday_last& mwdl) noexcept;
0677 constexpr year_month_weekday_last
0678 operator/(int y, const month_weekday_last& mwdl) noexcept;
0679 constexpr year_month_weekday_last
0680 operator/(const month_weekday_last& mwdl, const year& y) noexcept;
0681 constexpr year_month_weekday_last
0682 operator/(const month_weekday_last& mwdl, int y) noexcept;
0683
0684 // 26.9, class template hh_mm_ss
0685 template <class Duration>
0686 class hh_mm_ss
0687 {
0688 bool is_neg; // exposition only
0689 chrono::hours h; // exposition only
0690 chrono::minutes m; // exposition only
0691 chrono::seconds s; // exposition only
0692 precision ss; // exposition only
0693
0694 public:
0695 static unsigned constexpr fractional_width = see below;
0696 using precision = see below;
0697
0698 constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}
0699 constexpr explicit hh_mm_ss(Duration d) noexcept;
0700
0701 constexpr bool is_negative() const noexcept;
0702 constexpr chrono::hours hours() const noexcept;
0703 constexpr chrono::minutes minutes() const noexcept;
0704 constexpr chrono::seconds seconds() const noexcept;
0705 constexpr precision subseconds() const noexcept;
0706
0707 constexpr explicit operator precision() const noexcept;
0708 constexpr precision to_duration() const noexcept;
0709 };
0710
0711 template<class charT, class traits, class Duration>
0712 basic_ostream<charT, traits>&
0713 operator<<(basic_ostream<charT, traits>& os, const hh_mm_ss<Duration>& hms); // C++20
0714
0715 // 26.10, 12/24 hour functions
0716 constexpr bool is_am(hours const& h) noexcept;
0717 constexpr bool is_pm(hours const& h) noexcept;
0718 constexpr hours make12(const hours& h) noexcept;
0719 constexpr hours make24(const hours& h, bool is_pm) noexcept;
0720
0721 // [time.zone.db], time zone database
0722 struct tzdb { // C++20
0723 string version;
0724 vector<time_zone> zones;
0725 vector<time_zone_link> links;
0726 vector<leap_second> leap_seconds;
0727
0728 const time_zone* locate_zone(string_view tz_name) const;
0729 const time_zone* current_zone() const;
0730 };
0731
0732 class tzdb_list { // C++20
0733 public:
0734 tzdb_list(const tzdb_list&) = delete;
0735 tzdb_list& operator=(const tzdb_list&) = delete;
0736
0737 // unspecified additional constructors
0738
0739 class const_iterator;
0740
0741 const tzdb& front() const noexcept;
0742
0743 const_iterator erase_after(const_iterator p);
0744
0745 const_iterator begin() const noexcept;
0746 const_iterator end() const noexcept;
0747
0748 const_iterator cbegin() const noexcept;
0749 const_iterator cend() const noexcept;
0750 };
0751
0752 // [time.zone.db.access], time zone database access
0753 const tzdb& get_tzdb(); // C++20
0754 tzdb_list& get_tzdb_list(); // C++20
0755 const time_zone* locate_zone(string_view tz_name); // C++20
0756 const time_zone* current_zone() // C++20
0757
0758 // [time.zone.db.remote], remote time zone database support
0759 const tzdb& reload_tzdb(); // C++20
0760 string remote_version(); // C++20
0761
0762 // [time.zone.exception], exception classes
0763 class nonexistent_local_time; // C++20
0764 class ambiguous_local_time; // C++20
0765
0766 // [time.zone.info], information classes
0767 struct sys_info { // C++20
0768 sys_seconds begin;
0769 sys_seconds end;
0770 seconds offset;
0771 minutes save;
0772 string abbrev;
0773 };
0774
0775 template<class charT, class traits> // C++20
0776 basic_ostream<charT, traits>&
0777 operator<<(basic_ostream<charT, traits>& os, const sys_info& si);
0778
0779 struct local_info { // C++20
0780 static constexpr int unique = 0;
0781 static constexpr int nonexistent = 1;
0782 static constexpr int ambiguous = 2;
0783
0784 int result;
0785 sys_info first;
0786 sys_info second;
0787 };
0788
0789 template<class charT, class traits> // C++20
0790 basic_ostream<charT, traits>&
0791 operator<<(basic_ostream<charT, traits>& os, const local_info& li);
0792
0793 // 25.10.5, class time_zone // C++20
0794 enum class choose {earliest, latest};
0795 class time_zone {
0796 time_zone(time_zone&&) = default;
0797 time_zone& operator=(time_zone&&) = default;
0798
0799 // unspecified additional constructors
0800
0801 string_view name() const noexcept;
0802
0803 template<class Duration>
0804 sys_info get_info(const sys_time<Duration>& st) const;
0805
0806 template<class Duration>
0807 local_info get_info(const local_time<Duration>& tp) const;
0808
0809 template<class Duration>
0810 sys_time<common_type_t<Duration, seconds>>
0811 to_sys(const local_time<Duration>& tp) const;
0812
0813 template<class Duration>
0814 sys_time<common_type_t<Duration, seconds>>
0815 to_sys(const local_time<Duration>& tp, choose z) const;
0816
0817 template<class Duration>
0818 local_time<common_type_t<Duration, seconds>>
0819 to_local(const sys_time<Duration>& tp) const;
0820 };
0821 bool operator==(const time_zone& x, const time_zone& y) noexcept; // C++20
0822 strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept; // C++20
0823
0824 // [time.zone.zonedtraits], class template zoned_traits
0825 template<class T> struct zoned_traits; // C++20
0826
0827 // [time.zone.zonedtime], class template zoned_time
0828 template<class Duration, class TimeZonePtr = const time_zone*> // C++20
0829 class zoned_time;
0830
0831 using zoned_seconds = zoned_time<seconds>; // C++20
0832
0833 template<class Duration1, class Duration2, class TimeZonePtr> // C++20
0834 bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
0835 const zoned_time<Duration2, TimeZonePtr>& y);
0836
0837 template<class charT, class traits, class Duration, class TimeZonePtr> // C++20
0838 basic_ostream<charT, traits>&
0839 operator<<(basic_ostream<charT, traits>& os,
0840 const zoned_time<Duration, TimeZonePtr>& t);
0841
0842 // [time.zone.leap], leap second support
0843 class leap_second { // C++20
0844 public:
0845 leap_second(const leap_second&) = default;
0846 leap_second& operator=(const leap_second&) = default;
0847
0848 // unspecified additional constructors
0849
0850 constexpr sys_seconds date() const noexcept;
0851 constexpr seconds value() const noexcept;
0852 };
0853
0854 constexpr bool operator==(const leap_second& x, const leap_second& y); // C++20
0855 constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y);
0856
0857 template<class Duration> // C++20
0858 constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
0859 template<class Duration> // C++20
0860 constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
0861 template<class Duration> // C++20
0862 constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
0863 template<class Duration> // C++20
0864 constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
0865 template<class Duration> // C++20
0866 constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
0867 template<class Duration> // C++20
0868 constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
0869 template<class Duration> // C++20
0870 constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
0871 template<class Duration> // C++20
0872 constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
0873 template<class Duration> // C++20
0874 constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
0875 template<class Duration> // C++20
0876 requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
0877 constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
0878
0879 // [time.zone.link], class time_zone_link
0880 class time_zone_link { // C++20
0881 public:
0882 time_zone_link(time_zone_link&&) = default;
0883 time_zone_link& operator=(time_zone_link&&) = default;
0884
0885 // unspecified additional constructors
0886
0887 string_view name() const noexcept;
0888 string_view target() const noexcept;
0889 };
0890
0891 bool operator==(const time_zone_link& x, const time_zone_link& y); // C++20
0892 strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y); // C++20
0893
0894 } // chrono
0895
0896 namespace std {
0897 template<class Duration, class charT>
0898 struct formatter<chrono::sys_time<Duration>, charT>; // C++20
0899 template<class Duration, class charT>
0900 struct formatter<chrono::utc_time<Duration>, charT>; // C++20
0901 template<class Duration, class charT>
0902 struct formatter<chrono::filetime<Duration>, charT>; // C++20
0903 template<class Duration, class charT>
0904 struct formatter<chrono::local_time<Duration>, charT>; // C++20
0905 template<class Rep, class Period, class charT>
0906 struct formatter<chrono::duration<Rep, Period>, charT>; // C++20
0907 template<class charT> struct formatter<chrono::day, charT>; // C++20
0908 template<class charT> struct formatter<chrono::month, charT>; // C++20
0909 template<class charT> struct formatter<chrono::year, charT>; // C++20
0910 template<class charT> struct formatter<chrono::weekday, charT>; // C++20
0911 template<class charT> struct formatter<chrono::weekday_indexed, charT>; // C++20
0912 template<class charT> struct formatter<chrono::weekday_last, charT>; // C++20
0913 template<class charT> struct formatter<chrono::month_day, charT>; // C++20
0914 template<class charT> struct formatter<chrono::month_day_last, charT>; // C++20
0915 template<class charT> struct formatter<chrono::month_weekday, charT>; // C++20
0916 template<class charT> struct formatter<chrono::month_weekday_last, charT>; // C++20
0917 template<class charT> struct formatter<chrono::year_month, charT>; // C++20
0918 template<class charT> struct formatter<chrono::year_month_day, charT>; // C++20
0919 template<class charT> struct formatter<chrono::year_month_day_last, charT>; // C++20
0920 template<class charT> struct formatter<chrono::year_month_weekday, charT>; // C++20
0921 template<class charT> struct formatter<chrono::year_month_weekday_last, charT>; // C++20
0922 template<class Rep, class Period, class charT>
0923 struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>; // C++20
0924 template<class charT> struct formatter<chrono::sys_info, charT>; // C++20
0925 template<class charT> struct formatter<chrono::local_info, charT>; // C++20
0926 template<class Duration, class TimeZonePtr, class charT> // C++20
0927 struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;
0928 } // namespace std
0929
0930 namespace chrono {
0931 // calendrical constants
0932 inline constexpr last_spec last{}; // C++20
0933 inline constexpr chrono::weekday Sunday{0}; // C++20
0934 inline constexpr chrono::weekday Monday{1}; // C++20
0935 inline constexpr chrono::weekday Tuesday{2}; // C++20
0936 inline constexpr chrono::weekday Wednesday{3}; // C++20
0937 inline constexpr chrono::weekday Thursday{4}; // C++20
0938 inline constexpr chrono::weekday Friday{5}; // C++20
0939 inline constexpr chrono::weekday Saturday{6}; // C++20
0940
0941 inline constexpr chrono::month January{1}; // C++20
0942 inline constexpr chrono::month February{2}; // C++20
0943 inline constexpr chrono::month March{3}; // C++20
0944 inline constexpr chrono::month April{4}; // C++20
0945 inline constexpr chrono::month May{5}; // C++20
0946 inline constexpr chrono::month June{6}; // C++20
0947 inline constexpr chrono::month July{7}; // C++20
0948 inline constexpr chrono::month August{8}; // C++20
0949 inline constexpr chrono::month September{9}; // C++20
0950 inline constexpr chrono::month October{10}; // C++20
0951 inline constexpr chrono::month November{11}; // C++20
0952 inline constexpr chrono::month December{12}; // C++20
0953 } // chrono
0954
0955 inline namespace literals {
0956 inline namespace chrono_literals {
0957 constexpr chrono::hours operator ""h(unsigned long long); // C++14
0958 constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14
0959 constexpr chrono::minutes operator ""min(unsigned long long); // C++14
0960 constexpr chrono::duration<unspecified , ratio<60,1>> operator ""min(long double); // C++14
0961 constexpr chrono::seconds operator ""s(unsigned long long); // C++14
0962 constexpr chrono::duration<unspecified > operator ""s(long double); // C++14
0963 constexpr chrono::milliseconds operator ""ms(unsigned long long); // C++14
0964 constexpr chrono::duration<unspecified , milli> operator ""ms(long double); // C++14
0965 constexpr chrono::microseconds operator ""us(unsigned long long); // C++14
0966 constexpr chrono::duration<unspecified , micro> operator ""us(long double); // C++14
0967 constexpr chrono::nanoseconds operator ""ns(unsigned long long); // C++14
0968 constexpr chrono::duration<unspecified , nano> operator ""ns(long double); // C++14
0969 constexpr chrono::day operator ""d(unsigned long long d) noexcept; // C++20
0970 constexpr chrono::year operator ""y(unsigned long long y) noexcept; // C++20
0971 } // chrono_literals
0972 } // literals
0973
0974 } // std
0975 */
0976
0977 // clang-format on
0978
0979 #if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
0980 # include <__cxx03/chrono>
0981 #else
0982 # include <__config>
0983
0984 # include <__chrono/duration.h>
0985 # include <__chrono/file_clock.h>
0986 # include <__chrono/high_resolution_clock.h>
0987 # include <__chrono/steady_clock.h>
0988 # include <__chrono/system_clock.h>
0989 # include <__chrono/time_point.h>
0990
0991 # if _LIBCPP_STD_VER >= 20
0992 # include <__chrono/calendar.h>
0993 # include <__chrono/day.h>
0994 # include <__chrono/exception.h>
0995 # include <__chrono/hh_mm_ss.h>
0996 # include <__chrono/literals.h>
0997 # include <__chrono/local_info.h>
0998 # include <__chrono/month.h>
0999 # include <__chrono/month_weekday.h>
1000 # include <__chrono/monthday.h>
1001 # include <__chrono/sys_info.h>
1002 # include <__chrono/weekday.h>
1003 # include <__chrono/year.h>
1004 # include <__chrono/year_month.h>
1005 # include <__chrono/year_month_day.h>
1006 # include <__chrono/year_month_weekday.h>
1007
1008 # if _LIBCPP_HAS_LOCALIZATION
1009 # include <__chrono/formatter.h>
1010 # include <__chrono/ostream.h>
1011 # include <__chrono/parser_std_format_spec.h>
1012 # include <__chrono/statically_widen.h>
1013 # endif
1014
1015 # if _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION
1016 # include <__chrono/leap_second.h>
1017 # include <__chrono/time_zone.h>
1018 # include <__chrono/time_zone_link.h>
1019 # include <__chrono/tzdb.h>
1020 # include <__chrono/tzdb_list.h>
1021 # include <__chrono/utc_clock.h>
1022 # include <__chrono/zoned_time.h>
1023 # endif
1024
1025 # endif
1026
1027 # include <version>
1028
1029 // standard-mandated includes
1030
1031 // [time.syn]
1032 # include <compare>
1033
1034 # if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
1035 # pragma GCC system_header
1036 # endif
1037
1038 # if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
1039 # include <cstdint>
1040 # include <stdexcept>
1041 # include <string_view>
1042 # endif
1043
1044 # if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1045 # include <bit>
1046 # include <concepts>
1047 # include <cstring>
1048 # include <forward_list>
1049 # include <string>
1050 # include <tuple>
1051 # include <vector>
1052 # endif
1053
1054 # if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20
1055 # include <charconv>
1056 # if _LIBCPP_HAS_LOCALIZATION
1057 # include <locale>
1058 # include <ostream>
1059 # endif
1060 # endif
1061 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1062
1063 #endif // _LIBCPP_CHRONO
