[time.clock] (original) (raw)

27 Time library [time]

27.7 Clocks [time.clock]

The types defined in this subclause meet theCpp17TrivialClockrequirements ([time.clock.req]) unless otherwise specified.

27.7.1 Class system_­clock [time.clock.system]

27.7.1.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; static constexpr bool is_steady = unspecified;

static time_point now() noexcept;


static 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<Duration> 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

:

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

]

27.7.1.2 Members [time.clock.system.members]

using system_clock::rep = unspecified;

Constraints: system_­clock​::​duration​::​min() < system_­clock​::​duration​::​zero() is true.

[ Note

:

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 twhen 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 twhen 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.

27.7.1.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:

auto const dp = floor(tp); return os << format(os.getloc(), STATICALLY-WIDEN("{} {}"), year_month_day{dp}, hh_mm_ss{tp-dp});

[ Example

:

cout << sys_seconds{0s} << '\n';
cout << sys_seconds{946'684'800s} << '\n';
cout << sys_seconds{946'688'523s} << '\n';

— 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}.

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 isinto the sys_­time tp using the format flags given in the NTCTS fmtas 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.

27.7.2 Class utc_­clock [time.clock.utc]

27.7.2.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; static constexpr bool 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);

}; }

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

: 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

:
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 Cpp17TrivialClockunless the implementation can guarantee that utc_­clock​::​now()does not propagate an exception.

[ Note

:

noexcept(from_­sys(system_­clock​::​now())) is false.

— end note

]

27.7.2.2 Member functions [time.clock.utc.members]

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_­pointduring a positive leap second insertion, the conversion counts that leap second as not inserted, and the last representable value of sys_­timeprior 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

:

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

]

27.7.2.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(STATICALLY-WIDEN("{:%F %T}"), t);

[ Example

:

auto t = sys_days{July/1/2015} - 500ms; auto u = clock_cast(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 isinto the utc_­time tp using the format flags given in the NTCTS fmtas 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.

struct leap_second_info { bool is_leap_second; seconds elapsed;};

The type leap_­second_­infohas 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 trueif 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.

27.7.3 Class tai_­clock [time.clock.tai]

27.7.3.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; static constexpr bool is_steady = unspecified;

static time_point now();

template<class Duration>
  static utc_time<common_type_t<Duration, seconds>>
    to_utc(const tai_time<Duration>&) noexcept;
template<class Duration>
  static tai_time<common_type_t<Duration, seconds>>
    from_utc(const utc_time<Duration>&) 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 Cpp17TrivialClockunless the implementation can guarantee that tai_­clock​::​now()does not propagate an exception.

[ Note

:

noexcept(from_­utc(utc_­clock​::​now())) is false.

— end note

]

27.7.3.2 Member functions [time.clock.tai.members]

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

:

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

:

378691210s == sys_days{1970y/January/1} - sys_days{1958y/January/1} + 10s

— end note

]

27.7.3.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(STATICALLY-WIDEN("{:%F %T}"), t);

[ Example

:

auto st = sys_days{2000y/January/1}; auto tt = clock_cast(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 isinto the tai_­time tp using the format flags given in the NTCTS fmtas 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.

27.7.4 Class gps_­clock [time.clock.gps]

27.7.4.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; static constexpr bool is_steady = unspecified;

static time_point now();

template<class Duration>
  static utc_time<common_type_t<Duration, seconds>>
    to_utc(const gps_time<Duration>&) noexcept;
template<class Duration>
  static gps_time<common_type_t<Duration, seconds>>
    from_utc(const utc_time<Duration>&) 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 Cpp17TrivialClockunless the implementation can guarantee thatgps_­clock​::​now() does not propagate an exception.

[ Note

:

noexcept(from_­utc(utc_­clock​::​now())) is false.

— end note

]

27.7.4.2 Member functions [time.clock.gps.members]

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:

gps_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 315964809s

[ Note

:

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

:

315964809s == sys_days{1980y/January/Sunday[1]} - sys_days{1970y/January/1} + 9s

— end note

]

27.7.4.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(STATICALLY-WIDEN("{:%F %T}"), t);

[ Example

:

auto st = sys_days{2000y/January/1}; auto gt = clock_cast(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 isinto the gps_­time tp using the format flags given in the NTCTS fmtas 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.

27.7.5 Type file_­clock [time.clock.file]

27.7.5.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

:

The type that file_­clock denotes may be in a different namespace than std​::​chrono, such as std​::​filesystem.

— end note

]

27.7.5.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:

template static sys_time to_sys(const file_time&); template static file_time from_sys(const sys_time&);

or:

template static utc_time to_utc(const file_time&); template static file_time 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_­pointis computed from the Duration of the input time_­point.

27.7.5.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(STATICALLY-WIDEN("{:%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 isinto the file_­time tp using the format flags given in the NTCTS fmtas 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.

27.7.6 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_­pointnever 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.

27.7.7 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.

27.7.8 Local time [time.clock.local]

The family of time points denoted by local_­time<Duration>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<Duration> 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<Duration> (just as for sys_­time<Duration>).

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()};

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 isinto the local_­time tp using the format flags given in the NTCTS fmtas 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.

27.7.9 time_­point conversions [time.clock.cast]

27.7.9.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​::​durationwhose specialization is computed from the input Durationin a manner which can vary for each clock_­time_­conversion specialization.

A program may specialize clock_­time_­conversionif 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].

27.7.9.2 Identity conversions [time.clock.cast.id]

template struct 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;

template<> struct clock_time_conversion<system_clock, system_clock> { template sys_time operator()(const sys_time& t) const; };

template<class Duration> sys_time<Duration> operator()(const sys_time<Duration>& t) const;

template<> struct clock_time_conversion<utc_clock, utc_clock> { template utc_time operator()(const utc_time& t) const; };

template<class Duration> utc_time<Duration> operator()(const utc_time<Duration>& t) const;

27.7.9.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).

27.7.9.4 Conversions between system_­clock and other clocks [time.clock.cast.sys]

template struct clock_time_conversion<system_clock, SourceClock> { template auto 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<Duration>, where Duration is a valid chrono​::​duration specialization.

Returns: SourceClock​::​to_­sys(t).

template struct clock_time_conversion<DestClock, system_clock> { template auto 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, Duration>, where Duration is a valid chrono​::​duration specialization.

Returns: DestClock​::​from_­sys(t).

27.7.9.5 Conversions between utc_­clock and other clocks [time.clock.cast.utc]

template struct clock_time_conversion<utc_clock, SourceClock> { template auto 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<Duration>, where Duration is a valid chrono​::​duration specialization.

Returns: SourceClock​::​to_­utc(t).

template struct clock_time_conversion<DestClock, utc_clock> { template auto 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, Duration>, where Duration is a valid chrono​::​duration specialization.

Returns: DestClock​::​from_­utc(t).

27.7.9.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:

A clock time conversion expression is considered better than another clock time conversion expression if it involves feweroperator() calls on clock_­time_­conversionspecializations.

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.