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;
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 between
sys_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]
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 and
time_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 and
time_point. It is
implementation-defined
whether values are rounded or truncated to the required precision
.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, and
Duration{1} < days{1} is
true. Effects: Equivalent to:
return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{:L%F %T}"), tp);
[
Example 1:
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
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 and
tp 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.
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();
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 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 constant
sys_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]
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 that
u.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]
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<charT>("{: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 and
tp 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_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
.
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();
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
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]
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]
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<charT>("{: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 and
tp 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.
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();
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
Cpp17TrivialClock
unless the implementation can guarantee that
gps_clock::now() does not propagate an exception
. [
Note 1:
noexcept(from_utc(utc_clock::now())) is
false. —
end note]
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]
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<charT>("{: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 and
tp 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.
namespace std::chrono {
using file_clock = see below;
}
file_clock is used to create the
time_point system
used for
file_time_type (
[filesystems])
. Its epoch is unspecified, and
noexcept(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]
The type denoted by file_clock provides
precisely one of the following two sets of static member functions:
template<class Duration>
static sys_time<see below>
to_sys(const file_time<Duration>&);
template<class Duration>
static file_time<see below>
from_sys(const sys_time<Duration>&);
or:
template<class Duration>
static utc_time<see below>
to_utc(const file_time<Duration>&);
template<class Duration>
static file_time<see below>
from_utc(const utc_time<Duration>&);
These member functions shall provide
time_point conversions
consistent with those specified by
utc_clock,
tai_clock, and
gps_clock.The
Duration of the resultant
time_point
is computed from the
Duration of the input
time_point.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<charT>("{: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 and
tp 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.
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
.
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 for
system_clock or
steady_clock. 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<Duration>{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
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 and
tp 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
.
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 type
time_point<SourceClock, Duration>
to a destination
time_point of type
time_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
.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<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<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<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<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<class Duration>
sys_time<common_type_t<Duration, seconds>>
operator()(const utc_time<Duration>& 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). 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 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<Duration2>
for some type
Duration2 (
[time.point.general])
. Returns:
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 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). 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 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<Duration2>
for some type
Duration2 (
[time.point.general])
. Returns:
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));
};
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). 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 fewer
operator() 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
.