Defined in header <chrono> | ||
---|---|---|
template<class Dest, class Source> struct clock_time_conversion { }; | (since C++20) |
std::chrono::clock_time_conversion
is a trait that specifies how to convert a std::chrono::time_point
of the Source
clock to that of the Dest
clock. It does so by providing an const-callable operator()
that accepts an argument of type std::chrono::time_point<Source, Duration>
and returns a std::chrono::time_point<Dest, OtherDuration>
that represents an equivalent point in time. The duration of the returned time point is computed from the source duration in a manner that varies for each specialization. clock_time_conversion
is normally only used indirectly, via std::chrono::clock_cast
.
A program may specialize clock_time_conversion
if at least one of the template parameters is a user-defined clock type.
The primary template is an empty struct. The standard defines the following specializations:
template<class Clock> struct clock_time_conversion<Clock, Clock>; | (1) | (since C++20) |
template<> struct clock_time_conversion<std::chrono::system_clock, std::chrono::system_clock>; | (2) | (since C++20) |
template<> struct clock_time_conversion<std::chrono::utc_clock, std::chrono::utc_clock>; | (3) | (since C++20) |
template<> struct clock_time_conversion<std::chrono::system_clock, std::chrono::utc_clock>; | (4) | (since C++20) |
template<> struct clock_time_conversion<std::chrono::utc_clock, std::chrono::system_clock>; | (5) | (since C++20) |
template<class Clock> struct clock_time_conversion<Clock, std::chrono::system_clock>; | (6) | (since C++20) |
template<class Clock> struct clock_time_conversion<std::chrono::system_clock, Clock>; | (7) | (since C++20) |
template<class Clock> struct clock_time_conversion<Clock, std::chrono::utc_clock>; | (8) | (since C++20) |
template<class Clock> struct clock_time_conversion<std::chrono::utc_clock, Clock>; | (9) | (since C++20) |
operator()
returns a copy of the argument.std::chrono::sys_time
and std::chrono::utc_time
: operator()
calls std::chrono::utc_clock::to_sys
and std::chrono::utc_clock::from_sys
, respectively.std::chrono::sys_time
when Clock
supports from_sys
and to_sys
: operator()
calls Clock::to_sys
and Clock::from_sys
, respectively.std::chrono::utc_time
when Clock
supports from_utc
and to_utc
: operator()
calls Clock::to_utc
and Clock::from_utc
, respectively.Each specialization has an implicitly-declared default constructor, copy constructor, move constructor, copy assignment operator, move assignment operator, and destructor.
template <class Duration> std::chrono::time_point<Clock, Duration> operator()(const std::chrono::time_point<Clock, Duration>& t) const; | (1) | (member of specialization (1)) |
template <class Duration> std::chrono::sys_time<Duration> operator()(const std::chrono::sys_time<Duration> & t) const; | (2) | (member of specialization (2)) |
template <class Duration> std::chrono::utc_time<Duration> operator()(const std::chrono::utc_time<Duration>& t) const; | (3) | (member of specialization (3)) |
template <class Duration> std::chrono::sys_time<Duration> operator()(const std::chrono::utc_time<Duration>& t) const; | (4) | (member of specialization (4)) |
template <class Duration> std::chrono::utc_time<Duration> operator()(const std::chrono::sys_time<Duration>& t) const; | (5) | (member of specialization (5)) |
template <class Duration> auto operator()(const std::chrono::sys_time<Duration>& t) const -> decltype(Clock::from_sys(t)); | (6) | (member of specialization (6)) |
template <class Duration> auto operator()(const std::chrono::time_point<SourceClock, Duration>& t) const -> decltype(Clock::to_sys(t)); | (7) | (member of specialization (7)) |
template <class Duration> auto operator()(const std::chrono::utc_time<Duration>& t) const -> decltype(Clock::from_utc(t)); | (8) | (member of specialization (8)) |
template <class Duration> auto operator()(const std::chrono::time_point<Clock, Duration>& t) const -> decltype(Clock::to_utc(t)); | (9) | (member of specialization (9)) |
Converts the argument std::chrono::time_point
to the destination clock.
t
unchanged.std::chrono::utc_clock::to_sys(t)
.std::chrono::utc_clock::from_sys(t)
.Clock::from_sys(t)
. This overload only participates in overload resolution if the expression Clock::from_sys(t)
is well-formed. The program is ill-formed if Clock::from_sys(t)
does not return std::chrono::time_point<Clock, Duration>
where Duration
is some valid specialization of std::chrono::duration
.Clock::to_sys(t)
. This overload only participates in overload resolution if the expression Clock::to_sys(t)
is well-formed. The program is ill-formed if Clock::to_sys(t)
does not return std::chrono::sys_time<Duration>
where Duration
is some valid specialization of std::chrono::duration
.Clock::from_utc(t)
. This overload only participates in overload resolution if the expression Clock::from_utc(t)
is well-formed. The program is ill-formed if Clock::from_utc(t)
does not return std::chrono::time_point<Clock, Duration>
where Duration
is some valid specialization of std::chrono::duration
.Clock::to_utc(t)
. This overload only participates in overload resolution if the expression Clock::to_utc(t)
is well-formed. The program is ill-formed if Clock::to_utc(t)
does not return std::chrono::utc_time<Duration>
where Duration
is some valid specialization of std::chrono::duration
.t | - | time point to convert |
The result of the conversion as described above:
t
.Clock::from_sys(t)
. Clock::to_sys(t)
. Clock::from_utc(t)
.Clock::to_utc(t)
.
(C++20) | convert time points of one clock to another (function template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/chrono/clock_time_conversion