This header is part of thedate and time library.
Includes | ||
(C++20) | Three-way comparison operator support[edit] | |
Classes | ||
Duration | ||
Defined in namespace std::chrono | ||
(C++11) | a time interval (class template)[edit] | |
(C++11) | indicates that a duration is convertible to duration with different tick period (class template)[edit] | |
(C++11) | constructs zero, min, and max values of a tick count of given type (class template)[edit] | |
Convenience duration typedefs | ||
Defined in namespace std::chrono | ||
| std::chrono::nanoseconds(C++11) | duration type with Periodstd::nano | |
| std::chrono::microseconds(C++11) | duration type with Periodstd::micro | |
| std::chrono::milliseconds(C++11) | duration type with Periodstd::milli | |
| std::chrono::seconds(C++11) | duration type with Periodstd::ratio<1> | |
| std::chrono::minutes(C++11) | duration type with Periodstd::ratio<60> | |
| std::chrono::hours(C++11) | duration type with Periodstd::ratio<3600> | |
| std::chrono::days(C++20) | duration type with Periodstd::ratio<86400> | |
| std::chrono::weeks(C++20) | duration type with Periodstd::ratio<604800> | |
| std::chrono::months(C++20) | duration type with Periodstd::ratio<2629746> | |
| std::chrono::years(C++20) | duration type with Periodstd::ratio<31556952> | |
Time point | ||
Defined in namespace std::chrono | ||
(C++11) | a point in time (class template)[edit] | |
(C++20) | traits class defining how to convert time points of one clock to another (class template)[edit] | |
Clocks | ||
Defined in namespace std::chrono | ||
(C++20) | determines if a type is aClock (class template)(variable template)[edit] | |
(C++11) | wall clock time from the system-wide realtime clock (class)[edit] | |
(C++11) | monotonic clock that will never be adjusted (class)[edit] | |
(C++11) | the clock with the shortest tick period available (class)[edit] | |
(C++20) | Clock for Coordinated Universal Time (UTC) (class)[edit] | |
(C++20) | Clock for International Atomic Time (TAI) (class)[edit] | |
(C++20) | Clock for GPS time (class)[edit] | |
(C++20) | Clock used forfile time (typedef)[edit] | |
(C++20) | pseudo-clock representing local time (class)[edit] | |
Calendar | ||
Defined in namespace std::chrono | ||
(C++20) | tag class indicating thelast day or weekday in a month (class)[edit] | |
(C++20) | represents a day of a month (class)[edit] | |
(C++20) | represents a month of a year (class)[edit] | |
(C++20) | represents a year in the Gregorian calendar (class)[edit] | |
(C++20) | represents a day of the week in the Gregorian calendar (class)[edit] | |
(C++20) | represents the nthweekday of a month (class)[edit] | |
(C++20) | represents the lastweekday of a month (class)[edit] | |
(C++20) | represents a specificday of a specificmonth (class)[edit] | |
(C++20) | represents the last day of a specificmonth (class)[edit] | |
(C++20) | represents the nthweekday of a specificmonth (class)[edit] | |
(C++20) | represents the lastweekday of a specificmonth (class)[edit] | |
(C++20) | represents a specificmonth of a specificyear (class)[edit] | |
(C++20) | represents a specificyear,month, andday (class)[edit] | |
(C++20) | represents the last day of a specificyear andmonth (class)[edit] | |
(C++20) | represents the nthweekday of a specificyear andmonth (class)[edit] | |
(C++20) | represents the lastweekday of a specificyear andmonth (class)[edit] | |
Time of day | ||
Defined in namespace std::chrono | ||
(C++20) | represents a time of day (class template)[edit] | |
Time zone | ||
Defined in namespace std::chrono | ||
(C++20) | describes a copy of theIANA time zone database (class)[edit] | |
(C++20) | represents a linked list oftzdb (class)[edit] | |
(C++20) | represents a time zone (class)[edit] | |
(C++20) | represents information about a time zone at a particular time point (class)[edit] | |
(C++20) | represents information about a local time to UNIX time conversion (class)[edit] | |
(C++20) | selects how an ambiguous local time should be resolved (enum)[edit] | |
(C++20) | traits class for time zone pointers used byzoned_time (class template)[edit] | |
(C++20) | represents a time zone and a time point (class)[edit] | |
(C++20) | represents an alternative name for a time zone (class)[edit] | |
(C++20) | exception thrown to report that a local time is nonexistent (class)[edit] | |
(C++20) | exception thrown to report that a local time is ambiguous (class)[edit] | |
Leap second | ||
Defined in namespace std::chrono | ||
(C++20) | contains information about a leap second insertion (class)[edit] | |
(C++20) | leap second insertion information (class)[edit] | |
Specializations | ||
Defined in namespace std | ||
| specializes thestd::common_type trait (class template specialization)[edit] | ||
| specializes thestd::common_type trait (class template specialization)[edit] | ||
formatting support forduration(class template specialization)[edit] | ||
formatting support forsys_time(class template specialization)[edit] | ||
formatting support forutc_time(class template specialization)[edit] | ||
formatting support fortai_time(class template specialization)[edit] | ||
formatting support forgps_time(class template specialization)[edit] | ||
formatting support forfile_time(class template specialization)[edit] | ||
formatting support forlocal_time(class template specialization)[edit] | ||
formatting support forday(class template specialization)[edit] | ||
formatting support formonth(class template specialization)[edit] | ||
formatting support foryear(class template specialization)[edit] | ||
formatting support forweekday(class template specialization)[edit] | ||
formatting support forweekday_indexed(class template specialization)[edit] | ||
formatting support forweekday_last(class template specialization)[edit] | ||
formatting support formonth_day(class template specialization)[edit] | ||
formatting support formonth_day_last(class template specialization)[edit] | ||
formatting support formonth_weekday(class template specialization)[edit] | ||
formatting support formonth_weekday_last(class template specialization)[edit] | ||
formatting support foryear_month(class template specialization)[edit] | ||
formatting support foryear_month_day(class template specialization)[edit] | ||
formatting support foryear_month_day_last(class template specialization)[edit] | ||
formatting support foryear_month_weekday(class template specialization)[edit] | ||
formatting support foryear_month_weekday_last(class template specialization)[edit] | ||
formatting support forhh_mm_ss(class template specialization)[edit] | ||
formatting support forsys_info(class template specialization)[edit] | ||
formatting support forlocal_info(class template specialization)[edit] | ||
formatting support forzoned_time(class template specialization)[edit] | ||
| hash support forstd::chrono::duration (class template specialization) | ||
| hash support forstd::chrono::time_point (class template specialization) | ||
(C++26) | hash support forstd::chrono::day (class template specialization) | |
| hash support forstd::chrono::month (class template specialization) | ||
(C++26) | hash support forstd::chrono::year (class template specialization) | |
| hash support forstd::chrono::weekday (class template specialization) | ||
| hash support forstd::chrono::weekday_indexed (class template specialization) | ||
| hash support forstd::chrono::weekday_last (class template specialization) | ||
| hash support forstd::chrono::month_day (class template specialization) | ||
| hash support forstd::chrono::month_day_last (class template specialization) | ||
| hash support forstd::chrono::month_weekday (class template specialization) | ||
| hash support forstd::chrono::month_weekday_last (class template specialization) | ||
| hash support forstd::chrono::year_month (class template specialization) | ||
| hash support forstd::chrono::year_month_day (class template specialization) | ||
| hash support forstd::chrono::year_month_day_last (class template specialization) | ||
| hash support forstd::chrono::year_month_weekday (class template specialization) | ||
| hash support forstd::chrono::year_month_weekday_last (class template specialization) | ||
| hash support forstd::chrono::zoned_time (class template specialization) | ||
| hash support forstd::chrono::leap_second (class template specialization) | ||
Forward declarations | ||
Defined in header <functional> | ||
(C++11) | hash function object (class template)[edit] | |
Functions | |
Duration | |
Defined in namespace std::chrono | |
| implements arithmetic operations with durations as arguments (function template)[edit] | |
(C++11)(C++11)(removed in C++20)(C++11)(C++11)(C++11)(C++11)(C++20) | compares two durations (function template)[edit] |
(C++11) | converts a duration to another, with a different tick interval (function template)[edit] |
(C++17) | converts a duration to another, rounding down (function template)[edit] |
(C++17) | converts a duration to another, rounding up (function template)[edit] |
(C++17) | converts a duration to another, rounding to nearest, ties to even (function template)[edit] |
(C++17) | obtains the absolute value of the duration (function template)[edit] |
Time point | |
Defined in namespace std::chrono | |
(C++11) | performs add and subtract operations involving a time point (function template)[edit] |
(C++11)(C++11)(removed in C++20)(C++11)(C++11)(C++11)(C++11)(C++20) | compares two time points (function template)[edit] |
(C++11) | converts a time point to another time point on the same clock, with a different duration (function template)[edit] |
| converts a time_point to another, rounding down (function template)[edit] | |
| converts a time_point to another, rounding up (function template)[edit] | |
| converts a time_point to another, rounding to nearest, ties to even (function template)[edit] | |
parses asys_time from a stream according to the provided format(function template)[edit] | |
parses autc_time from a stream according to the provided format(function template)[edit] | |
parses atai_time from a stream according to the provided format(function template)[edit] | |
parses agps_time from a stream according to the provided format(function template)[edit] | |
parses afile_time from a stream according to the provided format(function template)[edit] | |
parses alocal_time from a stream according to the provided format(function template)[edit] | |
(C++20) | convert time points of one clock to another (function template)[edit] |
Calendar | |
Defined in namespace std::chrono | |
(C++20) | compares twoday values(function)[edit] |
(C++20) | compares twomonth values(function)[edit] |
(C++20) | compares twoyear values(function)[edit] |
(C++20) | compares twoweekday values(function)[edit] |
(C++20) | compares twoweekday_indexed values(function)[edit] |
(C++20) | compares twoweekday_last values(function)[edit] |
(C++20) | compares twomonth_day values(function)[edit] |
(C++20) | compares twomonth_day_last values(function)[edit] |
(C++20) | compares twomonth_weekday values(function)[edit] |
(C++20) | compares twomonth_weekday_last values(function)[edit] |
(C++20) | compares twoyear_month values(function)[edit] |
(C++20) | compares twoyear_month_day values(function)[edit] |
(C++20) | compares twoyear_month_day_last values(function)[edit] |
(C++20) | compares twoyear_month_weekday values(function)[edit] |
(C++20) | compares twoyear_month_weekday_last values(function)[edit] |
(C++20) | adds or subtracts a number of days and aday, or find the difference between twodays(function)[edit] |
(C++20) | performs arithmetic onmonths(function)[edit] |
(C++20) | performs arithmetic onyears(function)[edit] |
(C++20) | performs arithmetic onweekdays(function)[edit] |
(C++20) | performs arithmetic onyear_month(function)[edit] |
(C++20) | adds or subtracts ayear_month_day and some number of years or months(function)[edit] |
(C++20) | adds or subtracts ayear_month_day_last and some number of years or months(function)[edit] |
(C++20) | adds or subtracts ayear_month_weekday and some number of years or months(function)[edit] |
(C++20) | adds or subtracts ayear_month_weekday_last and some number of years or months(function)[edit] |
(C++20) | conventional syntax for Gregorian calendar date creation (function)[edit] |
Time of day | |
Defined in namespace std::chrono | |
(C++20) | translates between a 12h/24h format time of day (function)[edit] |
Time zone | |
Defined in namespace std::chrono | |
| accesses and controls the global time zone database information (function)[edit] | |
(C++20) | locates atime_zone based on its name (function)[edit] |
(C++20) | compares twotime_zone objects(function)[edit] |
(C++20) | compares twozoned_time values(function template)[edit] |
(C++20) | compares twotime_zone_link objects(function)[edit] |
Leap second | |
Defined in namespace std::chrono | |
(C++20) | obtains leap second insertion information from autc_time object(function template)[edit] |
compares twoleap_second values or aleap_second value and asys_time(function template)[edit] | |
I/O | |
Defined in namespace std::chrono | |
(C++20) | performs stream output on aduration(function template)[edit] |
performs stream output on asys_time(function template)[edit] | |
performs stream output on autc_time(function template)[edit] | |
performs stream output on atai_time(function template)[edit] | |
performs stream output on agps_time(function template)[edit] | |
performs stream output on afile_time(function template)[edit] | |
(C++20) | outputs aday into a stream(function template)[edit] |
(C++20) | outputs amonth into a stream(function template)[edit] |
(C++20) | outputs ayear into a stream(function template)[edit] |
(C++20) | outputs aweekday into a stream(function template)[edit] |
(C++20) | outputs aweekday_indexed into a stream(function template)[edit] |
(C++20) | outputs aweekday_last into a stream(function template)[edit] |
(C++20) | outputs amonth_day into a stream(function template)[edit] |
(C++20) | outputs amonth_day_last into a stream(function template)[edit] |
(C++20) | outputs amonth_weekday into a stream(function template)[edit] |
(C++20) | outputs amonth_weekday_last into a stream(function template)[edit] |
(C++20) | outputs ayear_month into a stream(function template)[edit] |
(C++20) | outputs ayear_month_day into a stream(function template)[edit] |
(C++20) | outputs ayear_month_day_last into a stream(function template)[edit] |
(C++20) | outputs ayear_month_weekday into a stream(function template)[edit] |
(C++20) | outputs ayear_month_weekday_last into a stream(function template)[edit] |
(C++20) | outputs ahh_mm_ss into a stream(function template)[edit] |
(C++20) | outputs asys_info into a stream(function template)[edit] |
(C++20) | outputs alocal_info into a stream(function template)[edit] |
(C++20) | outputs azoned_time into a stream(function template)[edit] |
(C++20) | parses aday from a stream according to the provided format(function template)[edit] |
(C++20) | parses amonth from a stream according to the provided format(function template)[edit] |
(C++20) | parses ayear from a stream according to the provided format(function template)[edit] |
(C++20) | parses aweekday from a stream according to the provided format(function template)[edit] |
(C++20) | parses amonth_day from a stream according to the provided format(function template)[edit] |
(C++20) | parses ayear_month from a stream according to the provided format(function template)[edit] |
(C++20) | parses ayear_month_day from a stream according to the provided format(function template)[edit] |
(C++20) | parses achrono object from a stream(function template)[edit] |
Literals | |
Defined in inline namespace std::literals::chrono_literals | |
(C++14) | astd::chrono::duration literal representing hours (function)[edit] |
(C++14) | astd::chrono::duration literal representing minutes (function)[edit] |
(C++14) | astd::chrono::duration literal representing seconds (function)[edit] |
(C++14) | astd::chrono::duration literal representing milliseconds (function)[edit] |
(C++14) | astd::chrono::duration literal representing microseconds (function)[edit] |
(C++14) | astd::chrono::duration literal representing nanoseconds (function)[edit] |
(C++20) | astd::chrono::day literal representing a day of a month (function)[edit] |
(C++20) | astd::chrono::year literal representing a particular year (function)[edit] |
#include <compare> namespace std{namespace chrono{// class template durationtemplate<class Rep,class Period= ratio<1>>class duration; // class template time_pointtemplate<class Clock,class Duration=typename Clock::duration>class time_point;} // common_type specializationstemplate<class Rep1,class Period1,class Rep2,class Period2>struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>; template<class Clock,class Duration1,class Duration2>struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>; namespace chrono{// customization traitstemplate<class Rep>struct treat_as_floating_point;template<class Rep>inlineconstexprbool treat_as_floating_point_v= treat_as_floating_point<Rep>::value; template<class Rep>struct duration_values; template<class T>struct is_clock;template<class T>inlineconstexprbool is_clock_v= is_clock<T>::value; // duration arithmetictemplate<class Rep1,class Period1,class Rep2,class Period2>constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>> operator+(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Rep2,class Period2>constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>> operator-(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period,class Rep2>constexpr duration<common_type_t<Rep1, Rep2>, Period> operator*(const duration<Rep1, Period>& d,const Rep2& s);template<class Rep1,class Rep2,class Period>constexpr duration<common_type_t<Rep1, Rep2>, Period> operator*(const Rep1& s,const duration<Rep2, Period>& d);template<class Rep1,class Period,class Rep2>constexpr duration<common_type_t<Rep1, Rep2>, Period> operator/(const duration<Rep1, Period>& d,const Rep2& s);template<class Rep1,class Period1,class Rep2,class Period2>constexpr common_type_t<Rep1, Rep2> operator/(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period,class Rep2>constexpr duration<common_type_t<Rep1, Rep2>, Period> operator%(const duration<Rep1, Period>& d,const Rep2& s);template<class Rep1,class Period1,class Rep2,class Period2>constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>> operator%(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs); // duration comparisonstemplate<class Rep1,class Period1,class Rep2,class Period2>constexprbool operator==(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Rep2,class Period2>constexprbool operator<(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Rep2,class Period2>constexprbool operator>(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Rep2,class Period2>constexprbool operator<=(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Rep2,class Period2>constexprbool operator>=(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Rep2,class Period2> requires/* see description */constexprauto operator<=>(const duration<Rep1, Period1>& lhs,const duration<Rep2, Period2>& rhs); // conversionstemplate<class ToDuration,class Rep,class Period>constexpr ToDuration duration_cast(const duration<Rep, Period>& d);template<class ToDuration,class Rep,class Period>constexpr ToDuration floor(const duration<Rep, Period>& d);template<class ToDuration,class Rep,class Period>constexpr ToDuration ceil(const duration<Rep, Period>& d);template<class ToDuration,class Rep,class Period>constexpr ToDuration round(const duration<Rep, Period>& d); // duration I/Otemplate<class CharT,class Traits,class Rep,class Period> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const duration<Rep, Period>& d);template<class CharT,class Traits,class Rep,class Period,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, duration<Rep, Period>& d, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // convenience typedefsusing nanoseconds= duration</* signed integer type of at least 64 bits */, nano>;using microseconds= duration</* signed integer type of at least 55 bits */, micro>;using milliseconds= duration</* signed integer type of at least 45 bits */, milli>;using seconds= duration</* signed integer type of at least 35 bits */>;using minutes= duration</* signed integer type of at least 29 bits */, ratio<60>>;using hours= duration</* signed integer type of at least 23 bits */, ratio<3600>>;using days= duration</* signed integer type of at least 25 bits */, ratio_multiply<ratio<24>, hours::period>>;using weeks= duration</* signed integer type of at least 22 bits */, ratio_multiply<ratio<7>, days::period>>;using years= duration</* signed integer type of at least 17 bits */, ratio_multiply<ratio<146097,400>, days::period>>;using months= duration</* signed integer type of at least 20 bits */, ratio_divide<years::period, ratio<12>>>; // time_point arithmetictemplate<class Clock,class Duration1,class Rep2,class Period2>constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>> operator+(const time_point<Clock, Duration1>& lhs,const duration<Rep2, Period2>& rhs);template<class Rep1,class Period1,class Clock,class Duration2>constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>> operator+(const duration<Rep1, Period1>& lhs,const time_point<Clock, Duration2>& rhs);template<class Clock,class Duration1,class Rep2,class Period2>constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>> operator-(const time_point<Clock, Duration1>& lhs,const duration<Rep2, Period2>& rhs);template<class Clock,class Duration1,class Duration2>constexpr common_type_t<Duration1, Duration2> operator-(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs); // time_point comparisonstemplate<class Clock,class Duration1,class Duration2>constexprbool operator==(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs);template<class Clock,class Duration1,class Duration2>constexprbool operator<(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs);template<class Clock,class Duration1,class Duration2>constexprbool operator>(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs);template<class Clock,class Duration1,class Duration2>constexprbool operator<=(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs);template<class Clock,class Duration1,class Duration2>constexprbool operator>=(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs);template<class Clock,class Duration1, three_way_comparable_with<Duration1> Duration2>constexprauto operator<=>(const time_point<Clock, Duration1>& lhs,const time_point<Clock, Duration2>& rhs); // conversionstemplate<class ToDuration,class Clock,class Duration>constexpr time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);template<class ToDuration,class Clock,class Duration>constexpr time_point<Clock, ToDuration> floor(const time_point<Clock, Duration>& tp);template<class ToDuration,class Clock,class Duration>constexpr time_point<Clock, ToDuration> ceil(const time_point<Clock, Duration>& tp);template<class ToDuration,class Clock,class Duration>constexpr time_point<Clock, ToDuration> round(const time_point<Clock, Duration>& tp); // specialized algorithmstemplate<class Rep,class Period>constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // class system_clockclass system_clock; template<class Duration>using sys_time= time_point<system_clock, Duration>;using sys_seconds= sys_time<seconds>;using sys_days= sys_time<days>; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const sys_time<Duration>& tp); template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const sys_days& dp); template<class CharT,class Traits,class Duration,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, sys_time<Duration>& tp, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class utc_clockclass utc_clock; template<class Duration>using utc_time= time_point<utc_clock, Duration>;using utc_seconds= utc_time<seconds>; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const utc_time<Duration>& t);template<class CharT,class Traits,class Duration,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, utc_time<Duration>& tp, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); struct leap_second_info; template<class Duration> leap_second_info get_leap_second_info(const utc_time<Duration>& ut); // class tai_clockclass tai_clock; template<class Duration>using tai_time= time_point<tai_clock, Duration>;using tai_seconds= tai_time<seconds>; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const tai_time<Duration>& t);template<class CharT,class Traits,class Duration,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, tai_time<Duration>& tp, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class gps_clockclass gps_clock; template<class Duration>using gps_time= time_point<gps_clock, Duration>;using gps_seconds= gps_time<seconds>; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const gps_time<Duration>& t);template<class CharT,class Traits,class Duration,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, gps_time<Duration>& tp, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // type file_clockusing file_clock=/* see description */; template<class Duration>using file_time= time_point<file_clock, Duration>; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const file_time<Duration>& tp);template<class CharT,class Traits,class Duration,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, file_time<Duration>& tp, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class steady_clockclass steady_clock; // class high_resolution_clockclass high_resolution_clock; // local timestruct local_t{};template<class Duration>using local_time= time_point<local_t, Duration>;using local_seconds= local_time<seconds>;using local_days= local_time<days>; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const local_time<Duration>& tp);template<class CharT,class Traits,class Duration,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, local_time<Duration>& tp, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // time_point conversionstemplate<class DestClock,class SourceClock>struct clock_time_conversion; template<class DestClock,class SourceClock,class Duration>auto clock_cast(const time_point<SourceClock, Duration>& t); // class last_specstruct last_spec; // class dayclass day; constexprbool operator==(const day& x,const day& y)noexcept;constexpr strong_ordering operator<=>(const day& x,const day& y)noexcept; constexpr day operator+(const day& x,const days& y)noexcept;constexpr day operator+(const days& x,const day& y)noexcept;constexpr day operator-(const day& x,const days& y)noexcept;constexpr days operator-(const day& x,const day& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const day& d);template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, day& d, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class monthclass month; constexprbool operator==(const month& x,const month& y)noexcept;constexpr strong_ordering operator<=>(const month& x,const month& y)noexcept; constexpr month operator+(const month& x,const months& y)noexcept;constexpr month operator+(const months& x,const month& y)noexcept;constexpr month operator-(const month& x,const months& y)noexcept;constexpr months operator-(const month& x,const month& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const month& m);template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, month& m, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class yearclass year; constexprbool operator==(const year& x,const year& y)noexcept;constexpr strong_ordering operator<=>(const year& x,const year& y)noexcept; constexpr year operator+(const year& x,const years& y)noexcept;constexpr year operator+(const years& x,const year& y)noexcept;constexpr year operator-(const year& x,const years& y)noexcept;constexpr years operator-(const year& x,const year& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const year& y); template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, year& y, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class weekdayclass weekday; constexprbool operator==(const weekday& x,const weekday& y)noexcept; constexpr weekday operator+(const weekday& x,const days& y)noexcept;constexpr weekday operator+(const days& x,const weekday& y)noexcept;constexpr weekday operator-(const weekday& x,const days& y)noexcept;constexpr days operator-(const weekday& x,const weekday& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const weekday& wd); template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, weekday& wd, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class weekday_indexedclass weekday_indexed; constexprbool operator==(const weekday_indexed& x,const weekday_indexed& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const weekday_indexed& wdi); // class weekday_lastclass weekday_last; constexprbool operator==(const weekday_last& x,const weekday_last& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const weekday_last& wdl); // class month_dayclass month_day; constexprbool operator==(const month_day& x,const month_day& y)noexcept;constexpr strong_ordering operator<=>(const month_day& x,const month_day& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const month_day& md); template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, month_day& md, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class month_day_lastclass month_day_last; constexprbool operator==(const month_day_last& x,const month_day_last& y)noexcept;constexpr strong_ordering operator<=>(const month_day_last& x,const month_day_last& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const month_day_last& mdl); // class month_weekdayclass month_weekday; constexprbool operator==(const month_weekday& x,const month_weekday& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const month_weekday& mwd); // class month_weekday_lastclass month_weekday_last; constexprbool operator==(const month_weekday_last& x,const month_weekday_last& y)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const month_weekday_last& mwdl); // class year_monthclass year_month; constexprbool operator==(const year_month& x,const year_month& y)noexcept;constexpr strong_ordering operator<=>(const year_month& x,const year_month& y)noexcept; constexpr year_month operator+(const year_month& ym,const months& dm)noexcept;constexpr year_month operator+(const months& dm,const year_month& ym)noexcept;constexpr year_month operator-(const year_month& ym,const months& dm)noexcept;constexpr months operator-(const year_month& x,const year_month& y)noexcept;constexpr year_month operator+(const year_month& ym,const years& dy)noexcept;constexpr year_month operator+(const years& dy,const year_month& ym)noexcept;constexpr year_month operator-(const year_month& ym,const years& dy)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const year_month& ym); template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, year_month& ym, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class year_month_dayclass year_month_day; constexprbool operator==(const year_month_day& x,const year_month_day& y)noexcept;constexpr strong_ordering operator<=>(const year_month_day& x,const year_month_day& y)noexcept; constexpr year_month_day operator+(const year_month_day& ymd,const months& dm)noexcept;constexpr year_month_day operator+(const months& dm,const year_month_day& ymd)noexcept;constexpr year_month_day operator+(const year_month_day& ymd,const years& dy)noexcept;constexpr year_month_day operator+(const years& dy,const year_month_day& ymd)noexcept;constexpr year_month_day operator-(const year_month_day& ymd,const months& dm)noexcept;constexpr year_month_day operator-(const year_month_day& ymd,const years& dy)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const year_month_day& ymd); template<class CharT,class Traits,class Alloc= allocator<CharT>> basic_istream<CharT, Traits>& from_stream(basic_istream<CharT, Traits>& is,const CharT* fmt, year_month_day& ymd, basic_string<CharT, Traits, Alloc>* abbrev= nullptr, minutes* offset= nullptr); // class year_month_day_lastclass year_month_day_last; constexprbool operator==(const year_month_day_last& x,const year_month_day_last& y)noexcept;constexpr strong_ordering operator<=>(const year_month_day_last& x,const year_month_day_last& y)noexcept; constexpr year_month_day_last operator+(const year_month_day_last& ymdl,const months& dm)noexcept;constexpr year_month_day_last operator+(const months& dm,const year_month_day_last& ymdl)noexcept;constexpr year_month_day_last operator+(const year_month_day_last& ymdl,const years& dy)noexcept;constexpr year_month_day_last operator+(const years& dy,const year_month_day_last& ymdl)noexcept;constexpr year_month_day_last operator-(const year_month_day_last& ymdl,const months& dm)noexcept;constexpr year_month_day_last operator-(const year_month_day_last& ymdl,const years& dy)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const year_month_day_last& ymdl); // class year_month_weekdayclass year_month_weekday; constexprbool operator==(const year_month_weekday& x,const year_month_weekday& y)noexcept; constexpr year_month_weekday operator+(const year_month_weekday& ymwd,const months& dm)noexcept;constexpr year_month_weekday operator+(const months& dm,const year_month_weekday& ymwd)noexcept;constexpr year_month_weekday operator+(const year_month_weekday& ymwd,const years& dy)noexcept;constexpr year_month_weekday operator+(const years& dy,const year_month_weekday& ymwd)noexcept;constexpr year_month_weekday operator-(const year_month_weekday& ymwd,const months& dm)noexcept;constexpr year_month_weekday operator-(const year_month_weekday& ymwd,const years& dy)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const year_month_weekday& ymwdi); // class year_month_weekday_lastclass year_month_weekday_last; constexprbool operator==(const year_month_weekday_last& x,const year_month_weekday_last& y)noexcept; constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl,const months& dm)noexcept;constexpr year_month_weekday_last operator+(const months& dm,const year_month_weekday_last& ymwdl)noexcept;constexpr year_month_weekday_last operator+(const year_month_weekday_last& ymwdl,const years& dy)noexcept;constexpr year_month_weekday_last operator+(const years& dy,const year_month_weekday_last& ymwdl)noexcept;constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl,const months& dm)noexcept;constexpr year_month_weekday_last operator-(const year_month_weekday_last& ymwdl,const years& dy)noexcept; template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const year_month_weekday_last& ymwdl); // civil calendar conventional syntax operatorsconstexpr year_month operator/(const year& y,const month& m)noexcept;constexpr year_month operator/(const year& y,int m)noexcept;constexpr month_day operator/(const month& m,const day& d)noexcept;constexpr month_day operator/(const month& m,int d)noexcept;constexpr month_day operator/(int m,const day& d)noexcept;constexpr month_day operator/(const day& d,const month& m)noexcept;constexpr month_day operator/(const day& d,int m)noexcept;constexpr month_day_last operator/(const month& m, last_spec)noexcept;constexpr month_day_last operator/(int m, last_spec)noexcept;constexpr month_day_last operator/(last_spec,const month& m)noexcept;constexpr month_day_last operator/(last_spec,int m)noexcept;constexpr month_weekday operator/(const month& m,const weekday_indexed& wdi)noexcept;constexpr month_weekday operator/(int m,const weekday_indexed& wdi)noexcept;constexpr month_weekday operator/(const weekday_indexed& wdi,const month& m)noexcept;constexpr month_weekday operator/(const weekday_indexed& wdi,int m)noexcept;constexpr month_weekday_last operator/(const month& m,const weekday_last& wdl)noexcept;constexpr month_weekday_last operator/(int m,const weekday_last& wdl)noexcept;constexpr month_weekday_last operator/(const weekday_last& wdl,const month& m)noexcept;constexpr month_weekday_last operator/(const weekday_last& wdl,int m)noexcept;constexpr year_month_day operator/(const year_month& ym,const day& d)noexcept;constexpr year_month_day operator/(const year_month& ym,int d)noexcept;constexpr year_month_day operator/(const year& y,const month_day& md)noexcept;constexpr year_month_day operator/(int y,const month_day& md)noexcept;constexpr year_month_day operator/(const month_day& md,const year& y)noexcept;constexpr year_month_day operator/(const month_day& md,int y)noexcept;constexpr year_month_day_last operator/(const year_month& ym, last_spec)noexcept;constexpr year_month_day_last operator/(const year& y,const month_day_last& mdl)noexcept;constexpr year_month_day_last operator/(int y,const month_day_last& mdl)noexcept;constexpr year_month_day_last operator/(const month_day_last& mdl,const year& y)noexcept;constexpr year_month_day_last operator/(const month_day_last& mdl,int y)noexcept;constexpr year_month_weekday operator/(const year_month& ym,const weekday_indexed& wdi)noexcept;constexpr year_month_weekday operator/(const year& y,const month_weekday& mwd)noexcept;constexpr year_month_weekday operator/(int y,const month_weekday& mwd)noexcept;constexpr year_month_weekday operator/(const month_weekday& mwd,const year& y)noexcept;constexpr year_month_weekday operator/(const month_weekday& mwd,int y)noexcept;constexpr year_month_weekday_last operator/(const year_month& ym,const weekday_last& wdl)noexcept;constexpr year_month_weekday_last operator/(const year& y,const month_weekday_last& mwdl)noexcept;constexpr year_month_weekday_last operator/(int y,const month_weekday_last& mwdl)noexcept;constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl,const year& y)noexcept;constexpr year_month_weekday_last operator/(const month_weekday_last& mwdl,int y)noexcept; // class template hh_mm_sstemplate<class Duration>class hh_mm_ss; template<class CharT,class Traits,class Duration> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const hh_mm_ss<Duration>& hms); // 12/24 hour functionsconstexprbool is_am(const hours& h)noexcept;constexprbool is_pm(const hours& h)noexcept;constexpr hours make12(const hours& h)noexcept;constexpr hours make24(const hours& h,bool is_pm)noexcept; // time zone databasestruct tzdb;class tzdb_list; // time zone database accessconst tzdb& get_tzdb(); tzdb_list& get_tzdb_list();const time_zone* locate_zone(string_view tz_name);const time_zone* current_zone(); // remote time zone database supportconst tzdb& reload_tzdb(); string remote_version(); // exception classesclass nonexistent_local_time;class ambiguous_local_time; // information classesstruct sys_info;template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const sys_info& si); struct local_info;template<class CharT,class Traits> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const local_info& li); // class time_zoneenumclass choose{earliest, latest};class time_zone; bool operator==(const time_zone& x,const time_zone& y)noexcept; strong_ordering operator<=>(const time_zone& x,const time_zone& y)noexcept; // class template zoned_traitstemplate<class T>struct zoned_traits; // class template zoned_timetemplate<class Duration,class TimeZonePtr=const time_zone*>class zoned_time; using zoned_seconds= zoned_time<seconds>; template<class Duration1,class Duration2,class TimeZonePtr>bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,const zoned_time<Duration2, TimeZonePtr>& y); template<class CharT,class Traits,class Duration,class TimeZonePtr> basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,const zoned_time<Duration, TimeZonePtr>& t); // leap second supportclass leap_second; bool operator==(const leap_second& x,const leap_second& y); strong_ordering operator<=>(const leap_second& x,const leap_second& y); template<class Duration>constexprbool operator==(const leap_second& x,const sys_time<Duration>& y);template<class Duration>constexprbool operator<(const leap_second& x,const sys_time<Duration>& y);template<class Duration>constexprbool operator<(const sys_time<Duration>& x,const leap_second& y);template<class Duration>constexprbool operator>(const leap_second& x,const sys_time<Duration>& y);template<class Duration>constexprbool operator>(const sys_time<Duration>& x,const leap_second& y);template<class Duration>constexprbool operator<=(const leap_second& x,const sys_time<Duration>& y);template<class Duration>constexprbool operator<=(const sys_time<Duration>& x,const leap_second& y);template<class Duration>constexprbool operator>=(const leap_second& x,const sys_time<Duration>& y);template<class Duration>constexprbool operator>=(const sys_time<Duration>& x,const leap_second& y);template<class Duration> requires three_way_comparable_with<sys_seconds, sys_time<Duration>>constexprauto operator<=>(const leap_second& x,const sys_time<Duration>& y); // class time_zone_linkclass time_zone_link; bool operator==(const time_zone_link& x,const time_zone_link& y); strong_ordering operator<=>(const time_zone_link& x,const time_zone_link& y); // formattingtemplate<class Duration>struct/*local-time-format-t*/;// exposition onlytemplate<class Duration>/*local-time-format-t*/<Duration> local_time_format(local_time<Duration> time,const string* abbrev= nullptr,const seconds* offset_sec= nullptr);} template<class Rep,class Period,class CharT>struct formatter<chrono::duration<Rep, Period>, CharT>;template<class Duration,class CharT>struct formatter<chrono::sys_time<Duration>, CharT>;template<class Duration,class CharT>struct formatter<chrono::utc_time<Duration>, CharT>;template<class Duration,class CharT>struct formatter<chrono::tai_time<Duration>, CharT>;template<class Duration,class CharT>struct formatter<chrono::gps_time<Duration>, CharT>;template<class Duration,class CharT>struct formatter<chrono::file_time<Duration>, CharT>;template<class Duration,class CharT>struct formatter<chrono::local_time<Duration>, CharT>;template<class Duration,class CharT>struct formatter<chrono::/*local-time-format-t*/<Duration>, CharT>;template<class CharT>struct formatter<chrono::day, CharT>;template<class CharT>struct formatter<chrono::month, CharT>;template<class CharT>struct formatter<chrono::year, CharT>;template<class CharT>struct formatter<chrono::weekday, CharT>;template<class CharT>struct formatter<chrono::weekday_indexed, CharT>;template<class CharT>struct formatter<chrono::weekday_last, CharT>;template<class CharT>struct formatter<chrono::month_day, CharT>;template<class CharT>struct formatter<chrono::month_day_last, CharT>;template<class CharT>struct formatter<chrono::month_weekday, CharT>;template<class CharT>struct formatter<chrono::month_weekday_last, CharT>;template<class CharT>struct formatter<chrono::year_month, CharT>;template<class CharT>struct formatter<chrono::year_month_day, CharT>;template<class CharT>struct formatter<chrono::year_month_day_last, CharT>;template<class CharT>struct formatter<chrono::year_month_weekday, CharT>;template<class CharT>struct formatter<chrono::year_month_weekday_last, CharT>;template<class Rep,class Period,class CharT>struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, CharT>;template<class CharT>struct formatter<chrono::sys_info, CharT>;template<class CharT>struct formatter<chrono::local_info, CharT>;template<class Duration,class TimeZonePtr,class CharT>struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, CharT>; namespace chrono{// parsingtemplate<class CharT,class Parsable>/* unspecified */ parse(const CharT* fmt, Parsable& tp); template<class CharT,class Traits,class Alloc,class Parsable>/* unspecified */ parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp); template<class CharT,class traits,class Alloc,class Parsable>/* unspecified */ parse(const CharT* fmt, Parsable& tp, basic_string<CharT, traits, Alloc>& abbrev); template<class CharT,class Traits,class Alloc,class Parsable>/* unspecified */ parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp, basic_string<CharT, Traits, Alloc>& abbrev); template<class CharT,class Parsable>/* unspecified */ parse(const CharT* fmt, Parsable& tp, minutes& offset); template<class CharT,class Traits,class Alloc,class Parsable>/* unspecified */ parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp, minutes& offset); template<class CharT,class traits,class Alloc,class Parsable>/* unspecified */ parse(const CharT* fmt, Parsable& tp, basic_string<CharT, traits, Alloc>& abbrev, minutes& offset); template<class CharT,class Traits,class Alloc,class Parsable>/* unspecified */ parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp, basic_string<CharT, Traits, Alloc>& abbrev, minutes& offset); // calendrical constantsinlineconstexpr last_spec last{}; inlineconstexpr weekday Sunday{0};inlineconstexpr weekday Monday{1};inlineconstexpr weekday Tuesday{2};inlineconstexpr weekday Wednesday{3};inlineconstexpr weekday Thursday{4};inlineconstexpr weekday Friday{5};inlineconstexpr weekday Saturday{6}; inlineconstexpr month January{1};inlineconstexpr month February{2};inlineconstexpr month March{3};inlineconstexpr month April{4};inlineconstexpr month May{5};inlineconstexpr month June{6};inlineconstexpr month July{7};inlineconstexpr month August{8};inlineconstexpr month September{9};inlineconstexpr month October{10};inlineconstexpr month November{11};inlineconstexpr month December{12};} inlinenamespace literals{inlinenamespace chrono_literals{// suffixes for duration literalsconstexpr chrono::hours operator""h(unsignedlonglong);constexpr chrono::duration</* unspecified */, ratio<3600,1>> operator""h(longdouble); constexpr chrono::minutes operator""min(unsignedlonglong);constexpr chrono::duration</* unspecified */, ratio<60,1>> operator""min(longdouble); constexpr chrono::seconds operator""s(unsignedlonglong);constexpr chrono::duration</* unspecified */> operator""s(longdouble); constexpr chrono::milliseconds operator""ms(unsignedlonglong);constexpr chrono::duration</* unspecified */, milli> operator""ms(longdouble); constexpr chrono::microseconds operator""us(unsignedlonglong);constexpr chrono::duration</* unspecified */, micro> operator""us(longdouble); constexpr chrono::nanoseconds operator""ns(unsignedlonglong);constexpr chrono::duration</* unspecified */, nano> operator""ns(longdouble); // non-member functionsconstexpr chrono::day operator""d(unsignedlonglong d)noexcept; // non-member functionsconstexpr chrono::year operator""y(unsignedlonglong y)noexcept;}} namespace chrono{usingnamespace literals::chrono_literals;} // hash supporttemplate<class T>struct hash;template<class Rep,class Period>struct hash<chrono::duration<Rep, Period>>;template<class Clock,class Duration>struct hash<chrono::time_point<Clock, Duration>>;template<>struct hash<chrono::day>;template<>struct hash<chrono::month>;template<>struct hash<chrono::year>;template<>struct hash<chrono::weekday>;template<>struct hash<chrono::weekday_indexed>;template<>struct hash<chrono::weekday_last>;template<>struct hash<chrono::month_day>;template<>struct hash<chrono::month_day_last>;template<>struct hash<chrono::month_weekday>;template<>struct hash<chrono::month_weekday_last>;template<>struct hash<chrono::year_month>;template<>struct hash<chrono::year_month_day>;template<>struct hash<chrono::year_month_day_last>;template<>struct hash<chrono::year_month_weekday>;template<>struct hash<chrono::year_month_weekday_last>;template<class Duration,class TimeZonePtr>struct hash<chrono::zoned_time<Duration, TimeZonePtr>>;template<>struct hash<chrono::leap_second>;}
namespace std::chrono{template<class Rep,class Period= ratio<1>>class duration{public:using rep= Rep;using period=typename Period::type; private: rep rep_;// exposition only public:// construct/copy/destroyconstexpr duration()=default;template<class Rep2>constexprexplicit duration(const Rep2& r);template<class Rep2,class Period2>constexpr duration(const duration<Rep2, Period2>& d); ~duration()=default; duration(const duration&)=default; duration& operator=(const duration&)=default; // observerconstexpr rep count()const; // arithmeticconstexpr common_type_t<duration> operator+()const;constexpr common_type_t<duration> operator-()const;constexpr duration& operator++();constexpr duration operator++(int);constexpr duration& operator--();constexpr duration operator--(int); constexpr duration& operator+=(const duration& d);constexpr duration& operator-=(const duration& d); constexpr duration& operator*=(const rep& rhs);constexpr duration& operator/=(const rep& rhs);constexpr duration& operator%=(const rep& rhs);constexpr duration& operator%=(const duration& rhs); // special valuesstaticconstexpr duration zero()noexcept;staticconstexpr duration min()noexcept;staticconstexpr duration max()noexcept;};}
namespace std::chrono{template<class Clock,class Duration=typename Clock::duration>class time_point{public:using clock= Clock;using duration= Duration;using rep=typename duration::rep;using period=typename duration::period; private: duration d_;// exposition only public:// constructconstexpr time_point();// has value epochconstexprexplicit time_point(const duration& d);// same as time_point() + dtemplate<class Duration2>constexpr time_point(const time_point<clock, Duration2>& t); // observerconstexpr duration time_since_epoch()const; // arithmeticconstexpr time_point& operator++();constexpr time_point operator++(int);constexpr time_point& operator--();constexpr time_point operator--(int);constexpr time_point& operator+=(const duration& d);constexpr time_point& operator-=(const duration& d); // special valuesstaticconstexpr time_point min()noexcept;staticconstexpr time_point max()noexcept;};}
namespace std{template<class Rep1,class Period1,class Rep2,class Period2>struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>{using type= chrono::duration<common_type_t<Rep1, Rep2>,/* see description */>;};}
namespace std{template<class Clock,class Duration1,class Duration2>struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>{using type= chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;};}
template<class Rep>struct treat_as_floating_point: is_floating_point<Rep>{};
namespace std::chrono{template<class Rep>struct duration_values{public:staticconstexpr Rep zero()noexcept;staticconstexpr Rep min()noexcept;staticconstexpr Rep max()noexcept;};}
namespace std::chrono{class system_clock{public:using rep=/* see description */;using period= ratio</* unspecified */,/* unspecified */>;using duration= chrono::duration<rep, period>;using time_point= chrono::time_point<system_clock>;staticconstexprbool is_steady=/* unspecified */; static time_point now()noexcept; // mapping to/from C type time_tstatic time_t to_time_t(const time_point& t)noexcept;static time_point from_time_t(time_t t)noexcept;};}
namespace std::chrono{class utc_clock{public:using rep=/* a signed arithmetic type */;using period= ratio</* unspecified */,/* unspecified */>;using duration= chrono::duration<rep, period>;using time_point= chrono::time_point<utc_clock>;staticconstexprbool is_steady=/* unspecified */; static time_point now(); template<class Duration>static sys_time<common_type_t<Duration, seconds>> to_sys(const utc_time<Duration>& t);template<class Duration>static utc_time<common_type_t<Duration, seconds>> from_sys(const sys_time<Duration>& t);};}
namespace std::chrono{class tai_clock{public:using rep=/* a signed arithmetic type */;using period= ratio</* unspecified */,/* unspecified */>;using duration= chrono::duration<rep, period>;using time_point= chrono::time_point<tai_clock>;staticconstexprbool is_steady=/* unspecified */; static time_point now(); template<class Duration>static sys_time<common_type_t<Duration, seconds>> to_sys(const tai_time<Duration>& t);template<class Duration>static tai_time<common_type_t<Duration, seconds>> from_sys(const sys_time<Duration>& t);};}
namespace std::chrono{class gps_clock{public:using rep=/* a signed arithmetic type */;using period= ratio</* unspecified */,/* unspecified */>;using duration= chrono::duration<rep, period>;using time_point= chrono::time_point<gps_clock>;staticconstexprbool is_steady=/* unspecified */; static time_point now(); template<class Duration>static sys_time<common_type_t<Duration, seconds>> to_sys(const gps_time<Duration>& t);template<class Duration>static gps_time<common_type_t<Duration, seconds>> from_sys(const sys_time<Duration>& t);};}
namespace std::chrono{class steady_clock{public:using rep=/* unspecified */;using period= ratio</* unspecified */,/* unspecified */>;using duration= chrono::duration<rep, period>;using time_point= chrono::time_point</* unspecified */, duration>;staticconstexprbool is_steady=true; static time_point now()noexcept;};}
namespace std::chrono{class high_resolution_clock{public:using rep=/* unspecified */;using period= ratio</* unspecified */,/* unspecified */>;using duration= chrono::duration<rep, period>;using time_point= chrono::time_point</* unspecified */, duration>;staticconstexprbool is_steady=/* unspecified */; static time_point now()noexcept;};}
namespace std::chrono{template<class DestClock,class SourceClock>struct clock_time_conversion{}; template<class Clock>struct clock_time_conversion<Clock, Clock>{template<class Duration> time_point<Clock, Duration> operator()(const time_point<Clock, Duration>& t)const;}; template<>struct clock_time_conversion<system_clock, system_clock>{template<class Duration> sys_time<Duration> operator()(const sys_time<Duration>& t)const;}; template<>struct clock_time_conversion<utc_clock, utc_clock>{template<class Duration> utc_time<Duration> operator()(const utc_time<Duration>& t)const;}; template<>struct clock_time_conversion<utc_clock, system_clock>{template<class Duration> utc_time<common_type_t<Duration, seconds>> operator()(const sys_time<Duration>& t)const;}; template<>struct clock_time_conversion<system_clock, utc_clock>{template<class Duration> sys_time<common_type_t<Duration, seconds>> operator()(const utc_time<Duration>& t)const;}; template<class SourceClock>struct clock_time_conversion<system_clock, SourceClock>{template<class Duration>auto operator()(const time_point<SourceClock, Duration>& t)const-> decltype(SourceClock::to_sys(t));}; template<class DestClock>struct clock_time_conversion<DestClock, system_clock>{template<class Duration>auto operator()(const sys_time<Duration>& t)const-> decltype(DestClock::from_sys(t));}; template<class SourceClock>struct clock_time_conversion<utc_clock, SourceClock>{template<class Duration>auto operator()(const time_point<SourceClock, Duration>& t)const-> decltype(SourceClock::to_utc(t));}; template<class DestClock>struct clock_time_conversion<DestClock, utc_clock>{template<class Duration>auto operator()(const utc_time<Duration>& t)const-> decltype(DestClock::from_utc(t));};}
namespace std::chrono{struct last_spec{explicit last_spec()=default;};}
namespace std::chrono{class day{unsignedchar d_;// exposition onlypublic: day()=default;constexprexplicit day(unsigned d)noexcept; constexpr day& operator++()noexcept;constexpr day operator++(int)noexcept;constexpr day& operator--()noexcept;constexpr day operator--(int)noexcept; constexpr day& operator+=(const days& d)noexcept;constexpr day& operator-=(const days& d)noexcept; constexprexplicit operatorunsigned()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class month{unsignedchar m_;// exposition onlypublic: month()=default;constexprexplicit month(unsigned m)noexcept; constexpr month& operator++()noexcept;constexpr month operator++(int)noexcept;constexpr month& operator--()noexcept;constexpr month operator--(int)noexcept; constexpr month& operator+=(const months& m)noexcept;constexpr month& operator-=(const months& m)noexcept; constexprexplicit operatorunsigned()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class year{short y_;// exposition onlypublic: year()=default;constexprexplicit year(int y)noexcept; constexpr year& operator++()noexcept;constexpr year operator++(int)noexcept;constexpr year& operator--()noexcept;constexpr year operator--(int)noexcept; constexpr year& operator+=(const years& y)noexcept;constexpr year& operator-=(const years& y)noexcept; constexpr year operator+()constnoexcept;constexpr year operator-()constnoexcept; constexprbool is_leap()constnoexcept; constexprexplicit operatorint()constnoexcept;constexprbool ok()constnoexcept; staticconstexpr year min()noexcept;staticconstexpr year max()noexcept;};}
namespace std::chrono{class weekday{unsignedchar wd_;// exposition onlypublic: weekday()=default;constexprexplicit weekday(unsigned wd)noexcept;constexpr weekday(const sys_days& dp)noexcept;constexprexplicit weekday(const local_days& dp)noexcept; constexpr weekday& operator++()noexcept;constexpr weekday operator++(int)noexcept;constexpr weekday& operator--()noexcept;constexpr weekday operator--(int)noexcept; constexpr weekday& operator+=(const days& d)noexcept;constexpr weekday& operator-=(const days& d)noexcept; constexprunsigned c_encoding()constnoexcept;constexprunsigned iso_encoding()constnoexcept;constexprbool ok()constnoexcept; constexpr weekday_indexed operator[](unsigned index)constnoexcept;constexpr weekday_last operator[](last_spec)constnoexcept;};}
namespace std::chrono{class weekday_indexed{ chrono::weekday wd_;// exposition onlyunsignedchar index_;// exposition only public: weekday_indexed()=default;constexpr weekday_indexed(const chrono::weekday& wd,unsigned index)noexcept; constexpr chrono::weekday weekday()constnoexcept;constexprunsigned index()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class weekday_last{ chrono::weekday wd_;// exposition only public:constexprexplicit weekday_last(const chrono::weekday& wd)noexcept; constexpr chrono::weekday weekday()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class month_day{ chrono::month m_;// exposition only chrono::day d_;// exposition only public: month_day()=default;constexpr month_day(const chrono::month& m,const chrono::day& d)noexcept; constexpr chrono::month month()constnoexcept;constexpr chrono::day day()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class month_day_last{ chrono::month m_;// exposition only public:constexprexplicit month_day_last(const chrono::month& m)noexcept; constexpr chrono::month month()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class month_weekday{ chrono::month m_;// exposition only chrono::weekday_indexed wdi_;// exposition onlypublic:constexpr month_weekday(const chrono::month& m,const chrono::weekday_indexed& wdi)noexcept; constexpr chrono::month month()constnoexcept;constexpr chrono::weekday_indexed weekday_indexed()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class month_weekday_last{ chrono::month m_;// exposition only chrono::weekday_last wdl_;// exposition onlypublic:constexpr month_weekday_last(const chrono::month& m,const chrono::weekday_last& wdl)noexcept; constexpr chrono::month month()constnoexcept;constexpr chrono::weekday_last weekday_last()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class year_month{ chrono::year y_;// exposition only chrono::month m_;// exposition only public: year_month()=default;constexpr year_month(const chrono::year& y,const chrono::month& m)noexcept; constexpr chrono::year year()constnoexcept;constexpr chrono::month month()constnoexcept; constexpr year_month& operator+=(const months& dm)noexcept;constexpr year_month& operator-=(const months& dm)noexcept;constexpr year_month& operator+=(const years& dy)noexcept;constexpr year_month& operator-=(const years& dy)noexcept; constexprbool ok()constnoexcept;};}
namespace std::chrono{class year_month_day{ chrono::year y_;// exposition only chrono::month m_;// exposition only chrono::day d_;// exposition only public: year_month_day()=default;constexpr year_month_day(const chrono::year& y,const chrono::month& m,const chrono::day& d)noexcept;constexpr year_month_day(const year_month_day_last& ymdl)noexcept;constexpr year_month_day(const sys_days& dp)noexcept;constexprexplicit year_month_day(const local_days& dp)noexcept; constexpr year_month_day& operator+=(const months& m)noexcept;constexpr year_month_day& operator-=(const months& m)noexcept;constexpr year_month_day& operator+=(const years& y)noexcept;constexpr year_month_day& operator-=(const years& y)noexcept; constexpr chrono::year year()constnoexcept;constexpr chrono::month month()constnoexcept;constexpr chrono::day day()constnoexcept; constexpr operator sys_days()constnoexcept;constexprexplicit operator local_days()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class year_month_day_last{ chrono::year y_;// exposition only chrono::month_day_last mdl_;// exposition only public:constexpr year_month_day_last(const chrono::year& y,const chrono::month_day_last& mdl)noexcept; constexpr year_month_day_last& operator+=(const months& m)noexcept;constexpr year_month_day_last& operator-=(const months& m)noexcept;constexpr year_month_day_last& operator+=(const years& y)noexcept;constexpr year_month_day_last& operator-=(const years& y)noexcept; constexpr chrono::year year()constnoexcept;constexpr chrono::month month()constnoexcept;constexpr chrono::month_day_last month_day_last()constnoexcept;constexpr chrono::day day()constnoexcept; constexpr operator sys_days()constnoexcept;constexprexplicit operator local_days()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class year_month_weekday{ chrono::year y_;// exposition only chrono::month m_;// exposition only chrono::weekday_indexed wdi_;// exposition only public: year_month_weekday()=default;constexpr year_month_weekday(const chrono::year& y,const chrono::month& m,const chrono::weekday_indexed& wdi)noexcept;constexpr year_month_weekday(const sys_days& dp)noexcept;constexprexplicit year_month_weekday(const local_days& dp)noexcept; constexpr year_month_weekday& operator+=(const months& m)noexcept;constexpr year_month_weekday& operator-=(const months& m)noexcept;constexpr year_month_weekday& operator+=(const years& y)noexcept;constexpr year_month_weekday& operator-=(const years& y)noexcept; constexpr chrono::year year()constnoexcept;constexpr chrono::month month()constnoexcept;constexpr chrono::weekday weekday()constnoexcept;constexprunsigned index()constnoexcept;constexpr chrono::weekday_indexed weekday_indexed()constnoexcept; constexpr operator sys_days()constnoexcept;constexprexplicit operator local_days()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{class year_month_weekday_last{ chrono::year y_;// exposition only chrono::month m_;// exposition only chrono::weekday_last wdl_;// exposition only public:constexpr year_month_weekday_last(const chrono::year& y,const chrono::month& m,const chrono::weekday_last& wdl)noexcept; constexpr year_month_weekday_last& operator+=(const months& m)noexcept;constexpr year_month_weekday_last& operator-=(const months& m)noexcept;constexpr year_month_weekday_last& operator+=(const years& y)noexcept;constexpr year_month_weekday_last& operator-=(const years& y)noexcept; constexpr chrono::year year()constnoexcept;constexpr chrono::month month()constnoexcept;constexpr chrono::weekday weekday()constnoexcept;constexpr chrono::weekday_last weekday_last()constnoexcept; constexpr operator sys_days()constnoexcept;constexprexplicit operator local_days()constnoexcept;constexprbool ok()constnoexcept;};}
namespace std::chrono{template<class Duration>class hh_mm_ss{public:staticconstexprunsigned fractional_width=/* see description */;using precision=/* see description */; constexpr hh_mm_ss()noexcept: hh_mm_ss{Duration::zero()}{}constexprexplicit hh_mm_ss(Duration d); constexprbool is_negative()constnoexcept;constexpr chrono::hours hours()constnoexcept;constexpr chrono::minutes minutes()constnoexcept;constexpr chrono::seconds seconds()constnoexcept;constexpr precision subseconds()constnoexcept; constexprexplicit operator precision()constnoexcept;constexpr precision to_duration()constnoexcept; private:bool is_neg;// exposition only chrono::hours h;// exposition only chrono::minutes m;// exposition only chrono::seconds s;// exposition only precision ss;// exposition only};}
namespace std::chrono{struct tzdb{ string version; vector<time_zone> zones; vector<time_zone_link> links; vector<leap_second> leap_seconds; const time_zone* locate_zone(string_view tz_name)const;const time_zone* current_zone()const;};}
namespace std::chrono{class tzdb_list{public: tzdb_list(const tzdb_list&)= delete; tzdb_list& operator=(const tzdb_list&)= delete; // unspecified additional constructors class const_iterator; const tzdb& front()constnoexcept; const_iterator erase_after(const_iterator p); const_iterator begin()constnoexcept; const_iterator end()constnoexcept; const_iterator cbegin()constnoexcept; const_iterator cend()constnoexcept;};}
namespace std::chrono{class nonexistent_local_time:public runtime_error{public:template<class Duration> nonexistent_local_time(const local_time<Duration>& tp,const local_info& i);};}
namespace std::chrono{class ambiguous_local_time:public runtime_error{public:template<class Duration> ambiguous_local_time(const local_time<Duration>& tp,const local_info& i);};}
namespace std::chrono{struct sys_info{ sys_seconds begin; sys_seconds end; seconds offset; minutes save; string abbrev;};}
namespace std::chrono{struct local_info{staticconstexprint unique=0;staticconstexprint nonexistent=1;staticconstexprint ambiguous=2; int result; sys_info first; sys_info second;};}
namespace std::chrono{class time_zone{public: time_zone(time_zone&&)=default; time_zone& operator=(time_zone&&)=default; // unspecified additional constructors string_view name()constnoexcept; template<class Duration> sys_info get_info(const sys_time<Duration>& st)const;template<class Duration> local_info get_info(const local_time<Duration>& tp)const; template<class Duration> sys_time<common_type_t<Duration, seconds>> to_sys(const local_time<Duration>& tp)const; template<class Duration> sys_time<common_type_t<Duration, seconds>> to_sys(const local_time<Duration>& tp, choose z)const; template<class Duration> local_time<common_type_t<Duration, seconds>> to_local(const sys_time<Duration>& tp)const;};}
namespace std::chrono{template<class T>struct zoned_traits{}; template<>struct zoned_traits<const time_zone*>{staticconst time_zone* default_zone();staticconst time_zone* locate_zone(string_view name);};}
namespace std::chrono{template<class Duration,class TimeZonePtr=const time_zone*>class zoned_time{public:using duration= common_type_t<Duration, seconds>; private: TimeZonePtr zone_;// exposition only sys_time<duration> tp_;// exposition only using traits= zoned_traits<TimeZonePtr>;// exposition only public: zoned_time(); zoned_time(const zoned_time&)=default; zoned_time& operator=(const zoned_time&)=default; zoned_time(const sys_time<Duration>& st);explicit zoned_time(TimeZonePtr z);explicit zoned_time(string_view name); template<class Duration2> zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt); zoned_time(TimeZonePtr z,const sys_time<Duration>& st); zoned_time(string_view name,const sys_time<Duration>& st); zoned_time(TimeZonePtr z,const local_time<Duration>& tp); zoned_time(string_view name,const local_time<Duration>& tp); zoned_time(TimeZonePtr z,const local_time<Duration>& tp, choose c); zoned_time(string_view name,const local_time<Duration>& tp, choose c); template<class Duration2,class TimeZonePtr2> zoned_time(TimeZonePtr z,const zoned_time<Duration2, TimeZonePtr2>& zt);template<class Duration2,class TimeZonePtr2> zoned_time(TimeZonePtr z,const zoned_time<Duration2, TimeZonePtr2>& zt, choose); template<class Duration2,class TimeZonePtr2> zoned_time(string_view name,const zoned_time<Duration2, TimeZonePtr2>& zt);template<class Duration2,class TimeZonePtr2> zoned_time(string_view name,const zoned_time<Duration2, TimeZonePtr2>& zt, choose); zoned_time& operator=(const sys_time<Duration>& st); zoned_time& operator=(const local_time<Duration>& ut); operator sys_time<duration>()const;explicit operator local_time<duration>()const; TimeZonePtr get_time_zone()const; local_time<duration> get_local_time()const; sys_time<duration> get_sys_time()const; sys_info get_info()const;}; zoned_time()-> zoned_time<seconds>; template<class Duration> zoned_time(sys_time<Duration>)-> zoned_time<common_type_t<Duration, seconds>>; template<class TimeZonePtrOrName>using/*time-zone-representation*/=// exposition only conditional_t<is_convertible_v<TimeZonePtrOrName, string_view>,const time_zone*, remove_cvref_t<TimeZonePtrOrName>>; template<class TimeZonePtrOrName> zoned_time(TimeZonePtrOrName&&)-> zoned_time<seconds,/*time-zone-representation*/<TimeZonePtrOrName>>; template<class TimeZonePtrOrName,class Duration> zoned_time(TimeZonePtrOrName&&, sys_time<Duration>)-> zoned_time<common_type_t<Duration, seconds>,/*time-zone-representation*/<TimeZonePtrOrName>>; template<class TimeZonePtrOrName,class Duration> zoned_time(TimeZonePtrOrName&&, local_time<Duration>, choose= choose::earliest)-> zoned_time<common_type_t<Duration, seconds>,/*time-zone-representation*/<TimeZonePtrOrName>>; template<class Duration,class TimeZonePtrOrName,class TimeZonePtr2> zoned_time(TimeZonePtrOrName&&, zoned_time<Duration, TimeZonePtr2>, choose= choose::earliest)-> zoned_time<common_type_t<Duration, seconds>,/*time-zone-representation*/<TimeZonePtrOrName>>;}
namespace std::chrono{class leap_second{public: leap_second(const leap_second&)=default; leap_second& operator=(const leap_second&)=default; // unspecified additional constructors constexpr sys_seconds date()constnoexcept;constexpr seconds value()constnoexcept;};}
namespace std::chrono{class time_zone_link{public: time_zone_link(time_zone_link&&)=default; time_zone_link& operator=(time_zone_link&&)=default; // unspecified additional constructors string_view name()constnoexcept; string_view target()constnoexcept;};}
namespace std::chrono{template<class Duration>struct/*local-time-format-t*/{// exposition only local_time<Duration> time;// exposition onlyconst string* abbrev;// exposition onlyconst seconds* offset_sec;// exposition only};}
