46 KiB
[time.clock]
30 Time library [time]
30.7 Clocks [time.clock]
30.7.1 General [time.clock.general]
The types defined in [time.clock] meet theCpp17TrivialClock requirements ([time.clock.req]) unless otherwise specified.
30.7.2 Class system_clock [time.clock.system]
30.7.2.1 Overview [time.clock.system.overview]
namespace std::chrono {class system_clock {public:using rep = see below; using period = ratio<unspecified, unspecified>; using duration = chrono::duration<rep, period>; using time_point = chrono::time_point<system_clock>; static constexpr bool 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; };}
Objects of type system_clock represent wall clock time from the system-wide realtime clock.
Objects of type sys_time measure time since 1970-01-01 00:00:00 UTC excluding leap seconds.
This measure is commonly referred to as Unix time.
This measure facilitates an efficient mapping betweensys_time and calendar types ([time.cal]).
[Example 1:
sys_seconds{sys_days{1970y/January/1}}.time_since_epoch() is 0s.
sys_seconds{sys_days{2000y/January/1}}.time_since_epoch() is 946'684'800s, which is 10'957 * 86'400s.
â end example]
30.7.2.2 Members [time.clock.system.members]
using system_clock::rep = unspecified;
Constraints: system_clock::duration::min() < system_clock::duration::zero() is true.
[Note 1:
This implies that rep is a signed type.
â end note]
static time_t to_time_t(const time_point& t) noexcept;
Returns: A time_t object that represents the same point in time as t when both values are restricted to the coarser of the precisions of time_t andtime_point.
It is implementation-defined whether values are rounded or truncated to the required precision.
static time_point from_time_t(time_t t) noexcept;
Returns: A time_point object that represents the same point in time as t when both values are restricted to the coarser of the precisions of time_t andtime_point.
It is implementation-defined whether values are rounded or truncated to the required precision.
30.7.2.3 Non-member functions [time.clock.system.nonmembers]
template<class charT, class traits, class Duration> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);
Constraints: treat_as_floating_point_v<typename Duration::rep> is false, andDuration{1} < days{1} is true.
Effects: Equivalent to:return os << format(os.getloc(), STATICALLY-WIDEN("{:L%F %T}"), tp);
[Example 1: cout << sys_seconds{0s} << '\n'; // 1970-01-01 00:00:00 cout << sys_seconds{946'684'800s} << '\n'; // 2000-01-01 00:00:00 cout << sys_seconds{946'688'523s} << '\n'; // 2000-01-01 01:02:03 â end example]
template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const sys_days& dp);
Effects: os << year_month_day{dp}.
Returns: os.
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);
Effects: Attempts to parse the input stream is into the sys_time tp using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid date,is.setstate(ios_base::failbit) is called andtp is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
Additionally, the parsed offset will be subtracted from the successfully parsed timestamp prior to assigning that difference to tp.
Returns: is.
30.7.3 Class utc_clock [time.clock.utc]
30.7.3.1 Overview [time.clock.utc.overview]
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>; static constexpr bool is_steady = unspecified; static time_point now(); templatestatic sys_time<common_type_t<Duration, seconds>> to_sys(const utc_time& t); templatestatic utc_time<common_type_t<Duration, seconds>> from_sys(const sys_time& t); };}
In contrast to sys_time, which does not take leap seconds into account,utc_clock and its associated time_point, utc_time, count time, including leap seconds, since 1970-01-01 00:00:00 UTC.
[Note 1:
The UTC time standard began on 1972-01-01 00:00:10 TAI. To measure time since this epoch instead, one can add/subtract the constantsys_days{1972y/1/1} - sys_days{1970y/1/1} (63'072'000s) from the utc_time.
â end note]
[Example 1:
clock_cast<utc_clock>(sys_seconds{sys_days{1970y/January/1}}).time_since_epoch() is 0s.
clock_cast<utc_clock>(sys_seconds{sys_days{2000y/January/1}}).time_since_epoch() is 946'684'822s,
which is 10'957 * 86'400s + 22s.
â end example]
utc_clock is not a Cpp17TrivialClock unless the implementation can guarantee that utc_clock::now() does not propagate an exception.
[Note 2:
noexcept(from_sys(system_clock::now())) is false.
â end note]
30.7.3.2 Member functions [time.clock.utc.members]
static time_point now();
Returns: from_sys(system_clock::now()), or a more accurate value of utc_time.
template<class Duration> static sys_time<common_type_t<Duration, seconds>> to_sys(const utc_time<Duration>& u);
Returns: A sys_time t, such that from_sys(t) == u if such a mapping exists.
Otherwise u represents a time_point during a positive leap second insertion, the conversion counts that leap second as not inserted, and the last representable value of sys_time prior to the insertion of the leap second is returned.
template<class Duration> static utc_time<common_type_t<Duration, seconds>> from_sys(const sys_time<Duration>& t);
Returns: A utc_time u, such thatu.time_since_epoch() - t.time_since_epoch() is equal to the sum of leap seconds that were inserted between t and 1970-01-01.
If t is exactly the date of leap second insertion, then the conversion counts that leap second as inserted.
[Example 1: auto t = sys_days{July/1/2015} - 2ns;auto u = utc_clock::from_sys(t); assert(u.time_since_epoch() - t.time_since_epoch() == 25s); t += 1ns; u = utc_clock::from_sys(t); assert(u.time_since_epoch() - t.time_since_epoch() == 25s); t += 1ns; u = utc_clock::from_sys(t); assert(u.time_since_epoch() - t.time_since_epoch() == 26s); t += 1ns; u = utc_clock::from_sys(t); assert(u.time_since_epoch() - t.time_since_epoch() == 26s); â end example]
30.7.3.3 Non-member functions [time.clock.utc.nonmembers]
template<class charT, class traits, class Duration> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const utc_time<Duration>& t);
Effects: Equivalent to:return os << format(os.getloc(), STATICALLY-WIDEN("{:L%F %T}"), t);
[Example 1: auto t = sys_days{July/1/2015} - 500ms;auto u = clock_cast<utc_clock>(t);for (auto i = 0; i < 8; ++i, u += 250ms) cout << u << " UTC\n";
Produces this output:
2015-06-30 23:59:59.500 UTC
2015-06-30 23:59:59.750 UTC
2015-06-30 23:59:60.000 UTC
2015-06-30 23:59:60.250 UTC
2015-06-30 23:59:60.500 UTC
2015-06-30 23:59:60.750 UTC
2015-07-01 00:00:00.000 UTC
2015-07-01 00:00:00.250 UTC
â end example]
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);
Effects: Attempts to parse the input stream is into the utc_time tp using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid date,is.setstate(ios_base::failbit) is called andtp is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
Additionally, the parsed offset will be subtracted from the successfully parsed timestamp prior to assigning that difference to tp.
Returns: is.
struct leap_second_info { bool is_leap_second; seconds elapsed; };
The type leap_second_info has data members and special members specified above.
It has no base classes or members other than those specified.
template<class Duration> leap_second_info get_leap_second_info(const utc_time<Duration>& ut);
Returns: A leap_second_info lsi, where lsi.is_leap_second is true if ut is during a positive leap second insertion, and otherwise false.
lsi.elapsed is the sum of leap seconds between 1970-01-01 and ut.
If lsi.is_leap_second is true, the leap second referred to by ut is included in the sum.
30.7.4 Class tai_clock [time.clock.tai]
30.7.4.1 Overview [time.clock.tai.overview]
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>; static constexpr bool is_steady = unspecified; static time_point now(); templatestatic utc_time<common_type_t<Duration, seconds>> to_utc(const tai_time&) noexcept; templatestatic tai_time<common_type_t<Duration, seconds>> from_utc(const utc_time&) noexcept; };}
The clock tai_clock measures seconds since 1958-01-01 00:00:00 and is offset 10s ahead of UTC at this date.
That is, 1958-01-01 00:00:00 TAI is equivalent to 1957-12-31 23:59:50 UTC.
Leap seconds are not inserted into TAI.
Therefore every time a leap second is inserted into UTC, UTC shifts another second with respect to TAI.
For example by 2000-01-01 there had been 22 positive and 0 negative leap seconds inserted so 2000-01-01 00:00:00 UTC is equivalent to 2000-01-01 00:00:32 TAI (22s plus the initial 10s offset).
tai_clock is not a Cpp17TrivialClock unless the implementation can guarantee that tai_clock::now() does not propagate an exception.
[Note 1:
noexcept(from_utc(utc_clock::now())) is false.
â end note]
30.7.4.2 Member functions [time.clock.tai.members]
static time_point now();
Returns: from_utc(utc_clock::now()), or a more accurate value of tai_time.
template<class Duration> static utc_time<common_type_t<Duration, seconds>> to_utc(const tai_time<Duration>& t) noexcept;
Returns: utc_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} - 378691210s
[Note 1: 378691210s == sys_days{1970y/January/1} - sys_days{1958y/January/1} + 10s â end note]
template<class Duration> static tai_time<common_type_t<Duration, seconds>> from_utc(const utc_time<Duration>& t) noexcept;
Returns: tai_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 378691210s
[Note 2: 378691210s == sys_days{1970y/January/1} - sys_days{1958y/January/1} + 10s â end note]
30.7.4.3 Non-member functions [time.clock.tai.nonmembers]
template<class charT, class traits, class Duration> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const tai_time<Duration>& t);
Effects: Equivalent to:return os << format(os.getloc(), STATICALLY-WIDEN("{:L%F %T}"), t);
[Example 1: auto st = sys_days{2000y/January/1};auto tt = clock_cast<tai_clock>(st); cout << format("{0:%F %T %Z} == {1:%F %T %Z}\n", st, tt);
Produces this output:
2000-01-01 00:00:00 UTC == 2000-01-01 00:00:32 TAI
â end example]
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);
Effects: Attempts to parse the input stream is into the tai_time tp using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid date,is.setstate(ios_base::failbit) is called andtp is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
Additionally, the parsed offset will be subtracted from the successfully parsed timestamp prior to assigning that difference to tp.
Returns: is.
30.7.5 Class gps_clock [time.clock.gps]
30.7.5.1 Overview [time.clock.gps.overview]
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>; static constexpr bool is_steady = unspecified; static time_point now(); templatestatic utc_time<common_type_t<Duration, seconds>> to_utc(const gps_time&) noexcept; templatestatic gps_time<common_type_t<Duration, seconds>> from_utc(const utc_time&) noexcept; };}
The clock gps_clock measures seconds since the first Sunday of January, 1980 00:00:00 UTC.
Leap seconds are not inserted into GPS.
Therefore every time a leap second is inserted into UTC, UTC shifts another second with respect to GPS.
Aside from the offset from 1958y/January/1 to 1980y/January/Sunday[1], GPS is behind TAI by 19s due to the 10s offset between 1958 and 1970 and the additional 9 leap seconds inserted between 1970 and 1980.
gps_clock is not a Cpp17TrivialClock unless the implementation can guarantee thatgps_clock::now() does not propagate an exception.
[Note 1:
noexcept(from_utc(utc_clock::now())) is false.
â end note]
30.7.5.2 Member functions [time.clock.gps.members]
static time_point now();
Returns: from_utc(utc_clock::now()), or a more accurate value of gps_time.
template<class Duration> static utc_time<common_type_t<Duration, seconds>> to_utc(const gps_time<Duration>& t) noexcept;
Returns: utc_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 315964809s
[Note 1: 315964809s == sys_days{1980y/January/Sunday[1]} - sys_days{1970y/January/1} + 9s â end note]
template<class Duration> static gps_time<common_type_t<Duration, seconds>> from_utc(const utc_time<Duration>& t) noexcept;
Returns: gps_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} - 315964809s
[Note 2: 315964809s == sys_days{1980y/January/Sunday[1]} - sys_days{1970y/January/1} + 9s â end note]
30.7.5.3 Non-member functions [time.clock.gps.nonmembers]
template<class charT, class traits, class Duration> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const gps_time<Duration>& t);
Effects: Equivalent to:return os << format(os.getloc(), STATICALLY-WIDEN("{:L%F %T}"), t);
[Example 1: auto st = sys_days{2000y/January/1};auto gt = clock_cast<gps_clock>(st); cout << format("{0:%F %T %Z} == {1:%F %T %Z}\n", st, gt);
Produces this output:
2000-01-01 00:00:00 UTC == 2000-01-01 00:00:13 GPS
â end example]
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);
Effects: Attempts to parse the input stream is into the gps_time tp using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid date,is.setstate(ios_base::failbit) is called andtp is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
Additionally, the parsed offset will be subtracted from the successfully parsed timestamp prior to assigning that difference to tp.
Returns: is.
30.7.6 Type file_clock [time.clock.file]
30.7.6.1 Overview [time.clock.file.overview]
namespace std::chrono {using file_clock = see below;}
file_clock is an alias for a type meeting the Cpp17TrivialClock requirements ([time.clock.req]), and using a signed arithmetic type for file_clock::rep.
file_clock is used to create the time_point system used for file_time_type ([filesystems]).
Its epoch is unspecified, andnoexcept(file_clock::now()) is true.
[Note 1:
The type that file_clock denotes can be in a different namespace than std::chrono, such as std::filesystem.
â end note]
30.7.6.2 Member functions [time.clock.file.members]
The type denoted by file_clock provides precisely one of the following two sets of static member functions:templatestatic sys_time<see below> to_sys(const file_time&);templatestatic file_time<see below> from_sys(const sys_time&); or:templatestatic utc_time<see below> to_utc(const file_time&);templatestatic file_time<see below> from_utc(const utc_time&);
These member functions shall provide time_point conversions consistent with those specified byutc_clock, tai_clock, and gps_clock.
The Duration of the resultant time_point is computed from the Duration of the input time_point.
30.7.6.3 Non-member functions [time.clock.file.nonmembers]
template<class charT, class traits, class Duration> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const file_time<Duration>& t);
Effects: Equivalent to:return os << format(os.getloc(), STATICALLY-WIDEN("{:L%F %T}"), 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, file_time<Duration>& tp, basic_string<charT, traits, Alloc>* abbrev = nullptr, minutes* offset = nullptr);
Effects: Attempts to parse the input stream is into the file_time tp using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid date,is.setstate(ios_base::failbit) is called andtp is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
Additionally, the parsed offset will be subtracted from the successfully parsed timestamp prior to assigning that difference to tp.
Returns: is.
30.7.7 Class steady_clock [time.clock.steady]
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>; static constexpr bool is_steady = true; static time_point now() noexcept; };}
Objects of class steady_clock represent clocks for which values of time_point never decrease as physical time advances and for which values of time_point advance at a steady rate relative to real time.
That is, the clock may not be adjusted.
30.7.8 Class high_resolution_clock [time.clock.hires]
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>; static constexpr bool is_steady = unspecified; static time_point now() noexcept; };}
Objects of class high_resolution_clock represent clocks with the shortest tick period.
high_resolution_clock may be a synonym forsystem_clock or steady_clock.
30.7.9 Local time [time.clock.local]
The family of time points denoted by local_time are based on the pseudo clock local_t.
local_t has no member now() and thus does not meet the clock requirements.
Nevertheless local_time serves the vital role of representing local time with respect to a not-yet-specified time zone.
Aside from being able to get the current time, the complete time_point algebra is available for local_time (just as for sys_time).
template<class charT, class traits, class Duration> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const local_time<Duration>& lt);
Effects: os << sys_time{lt.time_since_epoch()};
Returns: os.
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);
Effects: Attempts to parse the input stream is into the local_time tp using the format flags given in the NTCTS fmt as specified in [time.parse].
If the parse fails to decode a valid date,is.setstate(ios_base::failbit) is called andtp is not modified.
If %Z is used and successfully parsed, that value will be assigned to *abbrev if abbrev is non-null.
If %z (or a modified variant) is used and successfully parsed, that value will be assigned to *offset if offset is non-null.
Returns: is.
30.7.10 time_point conversions [time.clock.cast]
30.7.10.1 Class template clock_time_conversion [time.clock.conv]
namespace std::chrono {template<class DestClock, class SourceClock>struct clock_time_conversion {};}
clock_time_conversion serves as a trait which can be used to specify how to convert a source time_point of typetime_point<SourceClock, Duration> to a destination time_point of typetime_point<DestClock, Duration> via a specialization:clock_time_conversion<DestClock, SourceClock>.
A specialization of clock_time_conversion<DestClock, SourceClock> shall provide a const-qualified operator() that takes a parameter of type time_point<SourceClock, Duration> and returns a time_point<DestClock, OtherDuration> representing an equivalent point in time.
OtherDuration is a chrono::duration whose specialization is computed from the input Duration in a manner which can vary for each clock_time_conversion specialization.
A program may specialize clock_time_conversion if at least one of the template parameters is a user-defined clock type.
Several specializations are provided by the implementation, as described in[time.clock.cast.id],[time.clock.cast.sys.utc],[time.clock.cast.sys], and[time.clock.cast.utc].
30.7.10.2 Identity conversions [time.clock.cast.id]
templatestruct clock_time_conversion<Clock, Clock> {template time_point<Clock, Duration>operator()(const time_point<Clock, Duration>& t) const;};
template<class Duration> time_point<Clock, Duration> operator()(const time_point<Clock, Duration>& t) const;
Returns: t.
template<>struct clock_time_conversion<system_clock, system_clock> {template sys_timeoperator()(const sys_time& t) const;};
template<class Duration> sys_time<Duration> operator()(const sys_time<Duration>& t) const;
Returns: t.
template<>struct clock_time_conversion<utc_clock, utc_clock> {template utc_timeoperator()(const utc_time& t) const;};
template<class Duration> utc_time<Duration> operator()(const utc_time<Duration>& t) const;
Returns: t.
30.7.10.3 Conversions between system_clock and utc_clock [time.clock.cast.sys.utc]
template<>struct clock_time_conversion<utc_clock, system_clock> {template utc_time<common_type_t<Duration, seconds>>operator()(const sys_time& t) const;};
template<class Duration> utc_time<common_type_t<Duration, seconds>> operator()(const sys_time<Duration>& t) const;
Returns: utc_clock::from_sys(t).
template<>struct clock_time_conversion<system_clock, utc_clock> {template sys_time<common_type_t<Duration, seconds>>operator()(const utc_time& t) const;};
template<class Duration> sys_time<common_type_t<Duration, seconds>> operator()(const utc_time<Duration>& t) const;
Returns: utc_clock::to_sys(t).
30.7.10.4 Conversions between system_clock and other clocks [time.clock.cast.sys]
templatestruct clock_time_conversion<system_clock, SourceClock> {templateauto operator()(const time_point<SourceClock, Duration>& t) const-> decltype(SourceClock::to_sys(t));};
template<class Duration> auto operator()(const time_point<SourceClock, Duration>& t) const -> decltype(SourceClock::to_sys(t));
Constraints: SourceClock::to_sys(t) is well-formed.
Mandates: SourceClock::to_sys(t) returns a sys_time for some type Duration2 ([time.point.general]).
Returns: SourceClock::to_sys(t).
templatestruct clock_time_conversion<DestClock, system_clock> {templateauto operator()(const sys_time& t) const-> decltype(DestClock::from_sys(t));};
template<class Duration> auto operator()(const sys_time<Duration>& t) const -> decltype(DestClock::from_sys(t));
Constraints: DestClock::from_sys(t) is well-formed.
Mandates: DestClock::from_sys(t) returns a time_point<DestClock, Duration2> for some type Duration2 ([time.point.general]).
Returns: DestClock::from_sys(t).
30.7.10.5 Conversions between utc_clock and other clocks [time.clock.cast.utc]
templatestruct clock_time_conversion<utc_clock, SourceClock> {templateauto operator()(const time_point<SourceClock, Duration>& t) const-> decltype(SourceClock::to_utc(t));};
template<class Duration> auto operator()(const time_point<SourceClock, Duration>& t) const -> decltype(SourceClock::to_utc(t));
Constraints: SourceClock::to_utc(t) is well-formed.
Mandates: SourceClock::to_utc(t) returns a utc_time for some type Duration2 ([time.point.general]).
Returns: SourceClock::to_utc(t).
templatestruct clock_time_conversion<DestClock, utc_clock> {templateauto operator()(const utc_time& t) const-> decltype(DestClock::from_utc(t));};
template<class Duration> auto operator()(const utc_time<Duration>& t) const -> decltype(DestClock::from_utc(t));
Constraints: DestClock::from_utc(t) is well-formed.
Mandates: DestClock::from_utc(t) returns a time_point<DestClock, Duration2> for some type Duration2 ([time.point.general]).
Returns: DestClock::from_utc(t).
30.7.10.6 Function template clock_cast [time.clock.cast.fn]
template<class DestClock, class SourceClock, class Duration> auto clock_cast(const time_point<SourceClock, Duration>& t);
Constraints: At least one of the following clock time conversion expressions is well-formed:
clock_time_conversion<DestClock, SourceClock>{}(t)
clock_time_conversion<DestClock, system_clock>{}( clock_time_conversion<system_clock, SourceClock>{}(t))
clock_time_conversion<DestClock, utc_clock>{}( clock_time_conversion<utc_clock, SourceClock>{}(t))
clock_time_conversion<DestClock, utc_clock>{}( clock_time_conversion<utc_clock, system_clock>{}( clock_time_conversion<system_clock, SourceClock>{}(t)))
clock_time_conversion<DestClock, system_clock>{}( clock_time_conversion<system_clock, utc_clock>{}( clock_time_conversion<utc_clock, SourceClock>{}(t)))
A clock time conversion expression is considered better than another clock time conversion expression if it involves feweroperator() calls on clock_time_conversion specializations.
Mandates: Among the well-formed clock time conversion expressions from the above list, there is a unique best expression.
Returns: The best well-formed clock time conversion expression in the above list.