[time.clock] - C++17 → C++20

Files changed (1) hide show

tmp/tmpkh1arq3r/{from.md → to.md} +950 -23

tmp/tmpkh1arq3r/{from.md → to.md} RENAMED Viewed

@@ -1,39 +1,54 @@
-### Clocks <a id="time.clock">[[time.clock]]</a>
-The types defined in this subclause shall satisfy the `TrivialClock`
-requirements ([[time.clock.req]]).
-#### Class `system_clock` <a id="time.clock.system">[[time.clock.system]]</a>
-Objects of class `system_clock` represent wall clock time from the
-system-wide realtime clock.
 ``` cpp
   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;
- // Map to C API
     static time_t      to_time_t  (const time_point& t) noexcept;
     static time_point  from_time_t(time_t t) noexcept;
   };
 ```
 ``` cpp
 using system_clock::rep = unspecified;
 ```
-*Requires:*
-`system_clock::duration::min() < system_clock::duration::zero()` shall
-be `true`.
 [*Note 1*: This implies that `rep` is a signed type. — *end note*]
 ``` cpp
 static time_t to_time_t(const time_point& t) noexcept;
@@ -51,44 +66,956 @@ 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.
-#### Class `steady_clock` <a id="time.clock.steady">[[time.clock.steady]]</a>
 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.
 ``` cpp
-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;
   };
 ```
-#### Class `high_resolution_clock` <a id="time.clock.hires">[[time.clock.hires]]</a>
 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`.
 ``` cpp
-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;
 };
 ```

+## Clocks <a id="time.clock">[[time.clock]]</a>
+The types defined in this subclause meet the *Cpp17TrivialClock*
+requirements [[time.clock.req]] unless otherwise specified.
+### Class `system_clock` <a id="time.clock.system">[[time.clock.system]]</a>
+#### Overview <a id="time.clock.system.overview">[[time.clock.system.overview]]</a>
 ``` cpp
+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_t
     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*]
+#### Members <a id="time.clock.system.members">[[time.clock.system.members]]</a>
 ``` cpp
 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*]
 ``` cpp
 static time_t to_time_t(const time_point& 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.
+#### Non-member functions <a id="time.clock.system.nonmembers">[[time.clock.system.nonmembers]]</a>
+``` cpp
+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:
+``` cpp
+auto const dp = floor<days>(tp);
+return os << format(os.getloc(), STATICALLY-WIDEN<charT>("{} {}"),
+                    year_month_day{dp}, hh_mm_ss{tp-dp});
+```
+[*Example 1*:
+``` cpp
+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*]
+``` cpp
+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`.
+``` cpp
+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`.
+*Returns:* `is`.
+### Class `utc_clock` <a id="time.clock.utc">[[time.clock.utc]]</a>
+#### Overview <a id="time.clock.utc.overview">[[time.clock.utc.overview]]</a>
+``` cpp
+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*]
+#### Member functions <a id="time.clock.utc.members">[[time.clock.utc.members]]</a>
+``` cpp
+static time_point now();
+```
+*Returns:* `from_sys(system_clock::now())`, or a more accurate value of
+`utc_time`.
+``` cpp
+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.
+``` cpp
+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*:
+``` cpp
+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*]
+#### Non-member functions <a id="time.clock.utc.nonmembers">[[time.clock.utc.nonmembers]]</a>
+``` cpp
+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:
+``` cpp
+return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
+```
+[*Example 1*:
+``` cpp
+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:
+``` text
+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*]
+``` cpp
+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`.
+*Returns:* `is`.
+``` cpp
+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.
+``` cpp
+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.
+### Class `tai_clock` <a id="time.clock.tai">[[time.clock.tai]]</a>
+#### Overview <a id="time.clock.tai.overview">[[time.clock.tai.overview]]</a>
+``` cpp
+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*]
+#### Member functions <a id="time.clock.tai.members">[[time.clock.tai.members]]</a>
+``` cpp
+static time_point now();
+```
+*Returns:* `from_utc(utc_clock::now())`, or a more accurate value of
+`tai_time`.
+``` cpp
+template<class Duration>
+  static utc_time<common_type_t<Duration, seconds>>
+    to_utc(const tai_time<Duration>& t) noexcept;
+```
+*Returns:*
+``` cpp
+utc_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} - 378691210s
+```
+[*Note 1*:
+``` cpp
+378691210s == sys_days{1970y/January/1} - sys_days{1958y/January/1} + 10s
+```
+— *end note*]
+``` cpp
+template<class Duration>
+  static tai_time<common_type_t<Duration, seconds>>
+    from_utc(const utc_time<Duration>& t) noexcept;
+```
+*Returns:*
+``` cpp
+tai_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 378691210s
+```
+[*Note 2*:
+``` cpp
+378691210s == sys_days{1970y/January/1} - sys_days{1958y/January/1} + 10s
+```
+— *end note*]
+#### Non-member functions <a id="time.clock.tai.nonmembers">[[time.clock.tai.nonmembers]]</a>
+``` cpp
+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:
+``` cpp
+return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
+```
+[*Example 1*:
+``` cpp
+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:
+``` text
+2000-01-01 00:00:00 UTC == 2000-01-01 00:00:32 TAI
+```
+— *end example*]
+``` cpp
+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`.
+*Returns:* `is`.
+### Class `gps_clock` <a id="time.clock.gps">[[time.clock.gps]]</a>
+#### Overview <a id="time.clock.gps.overview">[[time.clock.gps.overview]]</a>
+``` cpp
+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*]
+#### Member functions <a id="time.clock.gps.members">[[time.clock.gps.members]]</a>
+``` cpp
+static time_point now();
+```
+*Returns:* `from_utc(utc_clock::now())`, or a more accurate value of
+`gps_time`.
+``` cpp
+template<class Duration>
+  static utc_time<common_type_t<Duration, seconds>>
+    to_utc(const gps_time<Duration>& t) noexcept;
+```
+*Returns:*
+``` cpp
+gps_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} + 315964809s
+```
+[*Note 1*:
+``` cpp
+315964809s == sys_days{1980y/January/Sunday[1]} - sys_days{1970y/January/1} + 9s
+```
+— *end note*]
+``` cpp
+template<class Duration>
+  static gps_time<common_type_t<Duration, seconds>>
+    from_utc(const utc_time<Duration>& t) noexcept;
+```
+*Returns:*
+``` cpp
+gps_time<common_type_t<Duration, seconds>>{t.time_since_epoch()} - 315964809s
+```
+[*Note 2*:
+``` cpp
+315964809s == sys_days{1980y/January/Sunday[1]} - sys_days{1970y/January/1} + 9s
+```
+— *end note*]
+#### Non-member functions <a id="time.clock.gps.nonmembers">[[time.clock.gps.nonmembers]]</a>
+``` cpp
+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:
+``` cpp
+return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
+```
+[*Example 1*:
+``` cpp
+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:
+``` text
+2000-01-01 00:00:00 UTC == 2000-01-01 00:00:13 GPS
+```
+— *end example*]
+``` cpp
+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`.
+*Returns:* `is`.
+### Type `file_clock` <a id="time.clock.file">[[time.clock.file]]</a>
+#### Overview <a id="time.clock.file.overview">[[time.clock.file.overview]]</a>
+``` cpp
+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, and `noexcept(file_clock::now())` is `true`.
+[*Note 1*: The type that `file_clock` denotes may be in a different
+namespace than `std::chrono`, such as `std::filesystem`. — *end note*]
+#### Member functions <a id="time.clock.file.members">[[time.clock.file.members]]</a>
+The type denoted by `file_clock` provides precisely one of the following
+two sets of static member functions:
+``` cpp
+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:
+``` cpp
+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`.
+#### Non-member functions <a id="time.clock.file.nonmembers">[[time.clock.file.nonmembers]]</a>
+``` cpp
+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:
+``` cpp
+return os << format(STATICALLY-WIDEN<charT>("{:%F %T}"), t);
+```
+``` cpp
+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`.
+*Returns:* `is`.
+### Class `steady_clock` <a id="time.clock.steady">[[time.clock.steady]]</a>
+``` cpp
+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.
+### Class `high_resolution_clock` <a id="time.clock.hires">[[time.clock.hires]]</a>
 ``` cpp
+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`.
+### Local time <a id="time.clock.local">[[time.clock.local]]</a>
+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>`).
+``` cpp
+template<class charT, class traits, class Duration>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const local_time<Duration>& lt);
+```
+*Effects:*
+``` cpp
+os << sys_time<Duration>{lt.time_since_epoch()};
+```
+*Returns:* `os`.
+``` cpp
+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.
+*Returns:* `is`.
+### `time_point` conversions <a id="time.clock.cast">[[time.clock.cast]]</a>
+#### Class template `clock_time_conversion` <a id="time.clock.conv">[[time.clock.conv]]</a>
+``` cpp
+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.
+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]].
+#### Identity conversions <a id="time.clock.cast.id">[[time.clock.cast.id]]</a>
+``` cpp
+template<class Clock>
+struct clock_time_conversion<Clock, Clock> {
+  template<class Duration>
+    time_point<Clock, Duration>
+      operator()(const time_point<Clock, Duration>& t) const;
+};
+```
+``` cpp
+template<class Duration>
+  time_point<Clock, Duration>
+    operator()(const time_point<Clock, Duration>& t) const;
+```
+*Returns:* `t`.
+``` cpp
+template<>
+struct clock_time_conversion<system_clock, system_clock> {
+  template<class Duration>
+    sys_time<Duration>
+      operator()(const sys_time<Duration>& t) const;
+};
+```
+``` cpp
+template<class Duration>
+  sys_time<Duration>
+    operator()(const sys_time<Duration>& t) const;
+```
+*Returns:* `t`.
+``` cpp
+template<>
+struct clock_time_conversion<utc_clock, utc_clock> {
+  template<class Duration>
+    utc_time<Duration>
+      operator()(const utc_time<Duration>& t) const;
+};
+```
+``` cpp
+template<class Duration>
+  utc_time<Duration>
+    operator()(const utc_time<Duration>& t) const;
+```
+*Returns:* `t`.
+#### Conversions between `system_clock` and `utc_clock` <a id="time.clock.cast.sys.utc">[[time.clock.cast.sys.utc]]</a>
+``` cpp
+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;
+};
+```
 ``` cpp
+template<class Duration>
+  utc_time<common_type_t<Duration, seconds>>
+    operator()(const sys_time<Duration>& t) const;
+```
+*Returns:* `utc_clock::from_sys(t)`.
+``` cpp
+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;
 };
 ```
+``` cpp
+template<class Duration>
+  sys_time<common_type_t<Duration, seconds>>
+    operator()(const utc_time<Duration>& t) const;
+```
+*Returns:* `utc_clock::to_sys(t)`.
+#### Conversions between `system_clock` and other clocks <a id="time.clock.cast.sys">[[time.clock.cast.sys]]</a>
+``` cpp
+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));
+};
+```
+``` cpp
+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)`.
+``` cpp
+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));
+};
+```
+``` cpp
+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)`.
+#### Conversions between `utc_clock` and other clocks <a id="time.clock.cast.utc">[[time.clock.cast.utc]]</a>
+``` cpp
+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));
+};
+```
+``` cpp
+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)`.
+``` cpp
+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));
+};
+```
+``` cpp
+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)`.
+#### Function template `clock_cast` <a id="time.clock.cast.fn">[[time.clock.cast.fn]]</a>
+``` cpp
+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:
+- ``` cpp
+  clock_time_conversion<DestClock, SourceClock>{}(t)
+  ```
+- ``` cpp
+  clock_time_conversion<DestClock, system_clock>{}(
+      clock_time_conversion<system_clock, SourceClock>{}(t))
+  ```
+- ``` cpp
+  clock_time_conversion<DestClock, utc_clock>{}(
+      clock_time_conversion<utc_clock, SourceClock>{}(t))
+  ```
+- ``` cpp
+  clock_time_conversion<DestClock, utc_clock>{}(
+      clock_time_conversion<utc_clock, system_clock>{}(
+          clock_time_conversion<system_clock, SourceClock>{}(t)))
+  ```
+- ``` cpp
+  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.

Diff to HTML by rtfpessoa