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

Files changed (1) hide show

tmp/tmpcz1vxsho/{from.md → to.md} +1206 -0

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

	@@ -0,0 +1,1206 @@

+## Time zones <a id="time.zone">[[time.zone]]</a>
+### In general <a id="time.zone.general">[[time.zone.general]]</a>
+[[time.zone]] describes an interface for accessing the IANA Time Zone
+Database that interoperates with `sys_time` and `local_time`. This
+interface provides time zone support to both the civil calendar types
+[[time.cal]] and to user-defined calendars.
+### Time zone database <a id="time.zone.db">[[time.zone.db]]</a>
+#### Class `tzdb` <a id="time.zone.db.tzdb">[[time.zone.db.tzdb]]</a>
+``` cpp
+namespace std::chrono {
+  struct tzdb {
+    string                 version;
+    vector<time_zone>      zones;
+    vector<time_zone_link> links;
+    vector<leap_second>    leap_seconds;
+    const time_zone* locate_zone(string_view tz_name) const;
+    const time_zone* current_zone() const;
+  };
+}
+```
+Each `vector` in a `tzdb` object is sorted to enable fast lookup.
+``` cpp
+const time_zone* locate_zone(string_view tz_name) const;
+```
+*Returns:*
+- If `zones` contains an element `tz` for which `tz.name() == tz_name`,
+  a pointer to `tz`;
+- otherwise, if `links` contains an element `tz_l` for which
+  `tz_l.name() == tz_name`, then a pointer to the element `tz` of
+  `zones` for which `tz.name() == tz_l.target()`.
+[*Note 1*: A `time_zone_link` specifies an alternative name for a
+`time_zone`. — *end note*]
+*Throws:* If a `const time_zone*` cannot be found as described in the
+*Returns:* clause, throws a `runtime_error`.
+[*Note 2*: On non-exceptional return, the return value is always a
+pointer to a valid `time_zone`. — *end note*]
+``` cpp
+const time_zone* current_zone() const;
+```
+*Returns:* A pointer to the time zone which the computer has set as its
+local time zone.
+#### Class `tzdb_list` <a id="time.zone.db.list">[[time.zone.db.list]]</a>
+``` cpp
+namespace std::chrono {
+  class tzdb_list {
+  public:
+    tzdb_list(const tzdb_list&) = delete;
+    tzdb_list& operator=(const tzdb_list&) = delete;
+    // unspecified additional constructors
+    class const_iterator;
+    const tzdb& front() const noexcept;
+    const_iterator erase_after(const_iterator p);
+    const_iterator begin() const noexcept;
+    const_iterator end()   const noexcept;
+    const_iterator cbegin() const noexcept;
+    const_iterator cend()   const noexcept;
+  };
+}
+```
+The `tzdb_list` database is a singleton; the unique object of type
+`tzdb_list` can be accessed via the `get_tzdb_list()` function.
+[*Note 1*: This access is only needed for those applications that need
+to have long uptimes and have a need to update the time zone database
+while running. Other applications can implicitly access the `front()` of
+this list via the read-only namespace scope functions `get_tzdb()`,
+`locate_zone()`, and `current_zone()`. — *end note*]
+The `tzdb_list` object contains a list of `tzdb` objects.
+`tzdb_list::const_iterator` is a constant iterator which meets the
+*Cpp17ForwardIterator* requirements and has a value type of `tzdb`.
+``` cpp
+const tzdb& front() const noexcept;
+```
+*Synchronization:* This operation is thread-safe with respect to
+`reload_tzdb()`.
+[*Note 1*: `reload_tzdb()` pushes a new `tzdb` onto the front of this
+container. — *end note*]
+*Returns:* A reference to the first `tzdb` in the container.
+``` cpp
+const_iterator erase_after(const_iterator p);
+```
+*Preconditions:* The iterator following `p` is dereferenceable.
+*Effects:* Erases the `tzdb` referred to by the iterator following `p`.
+*Returns:* An iterator pointing to the element following the one that
+was erased, or `end()` if no such element exists.
+*Ensures:* No pointers, references, or iterators are invalidated except
+those referring to the erased `tzdb`.
+[*Note 2*: It is not possible to erase the `tzdb` referred to by
+`begin()`. — *end note*]
+*Throws:* Nothing.
+``` cpp
+const_iterator begin() const noexcept;
+```
+*Returns:* An iterator referring to the first `tzdb` in the container.
+``` cpp
+const_iterator end() const noexcept;
+```
+*Returns:* An iterator referring to the position one past the last
+`tzdb` in the container.
+``` cpp
+const_iterator cbegin() const noexcept;
+```
+*Returns:* `begin()`.
+``` cpp
+const_iterator cend() const noexcept;
+```
+*Returns:* `end()`.
+#### Time zone database access <a id="time.zone.db.access">[[time.zone.db.access]]</a>
+``` cpp
+tzdb_list& get_tzdb_list();
+```
+*Effects:* If this is the first access to the time zone database,
+initializes the database. If this call initializes the database, the
+resulting database will be a `tzdb_list` holding a single initialized
+`tzdb`.
+*Synchronization:* It is safe to call this function from multiple
+threads at one time.
+*Returns:* A reference to the database.
+*Throws:* `runtime_error` if for any reason a reference cannot be
+returned to a valid `tzdb_list` containing one or more valid `tzdb`s.
+``` cpp
+const tzdb& get_tzdb();
+```
+*Returns:* `get_tzdb_list().front()`.
+``` cpp
+const time_zone* locate_zone(string_view tz_name);
+```
+*Returns:* `get_tzdb().locate_zone(tz_name)`.
+[*Note 1*: The time zone database will be initialized if this is the
+first reference to the database. — *end note*]
+``` cpp
+const time_zone* current_zone();
+```
+*Returns:* `get_tzdb().current_zone()`.
+#### Remote time zone database support <a id="time.zone.db.remote">[[time.zone.db.remote]]</a>
+The local time zone database is that supplied by the implementation when
+the program first accesses the database, for example via
+`current_zone()`. While the program is running, the implementation may
+choose to update the time zone database. This update shall not impact
+the program in any way unless the program calls the functions in this
+subclause. This potentially updated time zone database is referred to as
+the *remote time zone database*.
+``` cpp
+const tzdb& reload_tzdb();
+```
+*Effects:* This function first checks the version of the remote time
+zone database. If the versions of the local and remote databases are the
+same, there are no effects. Otherwise the remote database is pushed to
+the front of the `tzdb_list` accessed by `get_tzdb_list()`.
+*Synchronization:* This function is thread-safe with respect to
+`get_tzdb_list().front()` and `get_tzdb_list().erase_after()`.
+*Ensures:* No pointers, references, or iterators are invalidated.
+*Returns:* `get_tzdb_list().front()`.
+*Throws:* `runtime_error` if for any reason a reference cannot be
+returned to a valid `tzdb`.
+``` cpp
+string remote_version();
+```
+*Returns:* The latest remote database version.
+[*Note 1*: This can be compared with `get_tzdb().version` to discover
+if the local and remote databases are equivalent. — *end note*]
+### Exception classes <a id="time.zone.exception">[[time.zone.exception]]</a>
+#### Class `nonexistent_local_time` <a id="time.zone.exception.nonexist">[[time.zone.exception.nonexist]]</a>
+``` cpp
+namespace std::chrono {
+  class nonexistent_local_time : public runtime_error {
+  public:
+    template<class Duration>
+      nonexistent_local_time(const local_time<Duration>& tp, const local_info& i);
+  };
+}
+```
+`nonexistent_local_time` is thrown when an attempt is made to convert a
+non-existent `local_time` to a `sys_time` without specifying
+`choose::earliest` or `choose::latest`.
+``` cpp
+template<class Duration>
+  nonexistent_local_time(const local_time<Duration>& tp, const local_info& i);
+```
+*Preconditions:* `i.result == local_info::nonexistent` is `true`.
+*Effects:* Initializes the base class with a sequence of `char`
+equivalent to that produced by `os.str()` initialized as shown below:
+``` cpp
+ostringstream os;
+os << tp << " is in a gap between\n"
+   << local_seconds{i.first.end.time_since_epoch()} + i.first.offset << ' '
+   << i.first.abbrev << " and\n"
+   << local_seconds{i.second.begin.time_since_epoch()} + i.second.offset << ' '
+   << i.second.abbrev
+   << " which are both equivalent to\n"
+   << i.first.end << " UTC";
+```
+[*Example 1*:
+``` cpp
+#include <chrono>
+#include <iostream>
+int main() {
+  using namespace std::chrono;
+  try {
+    auto zt = zoned_time{"America/New_York",
+                         local_days{Sunday[2]/March/2016} + 2h + 30min};
+  } catch (const nonexistent_local_time& e) {
+    std::cout << e.what() << '\n';
+  }
+}
+```
+Produces the output:
+``` text
+2016-03-13 02:30:00 is in a gap between
+2016-03-13 02:00:00 EST and
+2016-03-13 03:00:00 EDT which are both equivalent to
+2016-03-13 07:00:00 UTC
+```
+— *end example*]
+#### Class `ambiguous_local_time` <a id="time.zone.exception.ambig">[[time.zone.exception.ambig]]</a>
+``` cpp
+namespace std::chrono {
+  class ambiguous_local_time : public runtime_error {
+  public:
+    template<class Duration>
+      ambiguous_local_time(const local_time<Duration>& tp, const local_info& i);
+  };
+}
+```
+`ambiguous_local_time` is thrown when an attempt is made to convert an
+ambiguous `local_time` to a `sys_time` without specifying
+`choose::earliest` or `choose::latest`.
+``` cpp
+template<class Duration>
+  ambiguous_local_time(const local_time<Duration>& tp, const local_info& i);
+```
+*Preconditions:* `i.result == local_info::ambiguous` is `true`.
+*Effects:* Initializes the base class with a sequence of `char`
+equivalent to that produced by `os.str()` initialized as shown below:
+``` cpp
+ostringstream os;
+os << tp << " is ambiguous.  It could be\n"
+   << tp << ' ' << i.first.abbrev << " == "
+   << tp - i.first.offset << " UTC or\n"
+   << tp << ' ' << i.second.abbrev  << " == "
+   << tp - i.second.offset  << " UTC";
+```
+[*Example 1*:
+``` cpp
+#include <chrono>
+#include <iostream>
+int main() {
+  using namespace std::chrono;
+  try {
+    auto zt = zoned_time{"America/New_York",
+                         local_days{Sunday[1]/November/2016} + 1h + 30min};
+  } catch (const ambiguous_local_time& e) {
+    std::cout << e.what() << '\n';
+  }
+}
+```
+Produces the output:
+``` text
+2016-11-06 01:30:00 is ambiguous.  It could be
+2016-11-06 01:30:00 EDT == 2016-11-06 05:30:00 UTC or
+2016-11-06 01:30:00 EST == 2016-11-06 06:30:00 UTC
+```
+— *end example*]
+### Information classes <a id="time.zone.info">[[time.zone.info]]</a>
+#### Class `sys_info` <a id="time.zone.info.sys">[[time.zone.info.sys]]</a>
+``` cpp
+namespace std::chrono {
+  struct sys_info {
+    sys_seconds   begin;
+    sys_seconds   end;
+    seconds       offset;
+    minutes       save;
+    string        abbrev;
+  };
+}
+```
+A `sys_info` object can be obtained from the combination of a
+`time_zone` and either a `sys_time` or `local_time`. It can also be
+obtained from a `zoned_time`, which is effectively a pair of a
+`time_zone` and `sys_time`.
+[*Note 1*: This type provides a low-level interface to time zone
+information. Typical conversions from `sys_time` to `local_time` will
+use this class implicitly, not explicitly. — *end note*]
+The `begin` and `end` data members indicate that, for the associated
+`time_zone` and `time_point`, the `offset` and `abbrev` are in effect in
+the range \[`begin`, `end`). This information can be used to efficiently
+iterate the transitions of a `time_zone`.
+The `offset` data member indicates the UTC offset in effect for the
+associated `time_zone` and `time_point`. The relationship between
+`local_time` and `sys_time` is:
+``` cpp
+offset = local_time - sys_time
+```
+The `save` data member is extra information not normally needed for
+conversion between `local_time` and `sys_time`. If `save != 0min`, this
+`sys_info` is said to be on “daylight saving” time, and `offset - save`
+suggests what offset this `time_zone` might use if it were off daylight
+saving time. However, this information should not be taken as
+authoritative. The only sure way to get such information is to query the
+`time_zone` with a `time_point` that returns a `sys_info` where
+`save == 0min`. There is no guarantee what `time_point` might return
+such a `sys_info` except that it is guaranteed not to be in the range
+\[`begin`, `end`) (if `save != 0min` for this `sys_info`).
+The `abbrev` data member indicates the current abbreviation used for the
+associated `time_zone` and `time_point`. Abbreviations are not unique
+among the `time_zones`, and so one cannot reliably map abbreviations
+back to a `time_zone` and UTC offset.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const sys_info& r);
+```
+*Effects:* Streams out the `sys_info` object `r` in an unspecified
+format.
+*Returns:* `os`.
+#### Class `local_info` <a id="time.zone.info.local">[[time.zone.info.local]]</a>
+``` cpp
+namespace std::chrono {
+  struct local_info {
+    static constexpr int unique      = 0;
+    static constexpr int nonexistent = 1;
+    static constexpr int ambiguous   = 2;
+    int result;
+    sys_info first;
+    sys_info second;
+  };
+}
+```
+[*Note 1*: This type provides a low-level interface to time zone
+information. Typical conversions from `local_time` to `sys_time` will
+use this class implicitly, not explicitly. — *end note*]
+Describes the result of converting a `local_time` to a `sys_time` as
+follows:
+- When a `local_time` to `sys_time` conversion is unique,
+  `result == unique`, `first` will be filled out with the correct
+  `sys_info`, and `second` will be zero-initialized.
+- If the conversion stems from a nonexistent `local_time` then
+  `result == nonexistent`, `first` will be filled out with the
+  `sys_info` that ends just prior to the `local_time`, and `second` will
+  be filled out with the `sys_info` that begins just after the
+  `local_time`.
+- If the conversion stems from an ambiguous `local_time`, then
+  `result == ambiguous`, `first` will be filled out with the `sys_info`
+  that ends just after the `local_time`, and `second` will be filled out
+  with the `sys_info` that starts just before the `local_time`.
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const local_info& r);
+```
+*Effects:* Streams out the `local_info` object `r` in an unspecified
+format.
+*Returns:* `os`.
+### Class `time_zone` <a id="time.zone.timezone">[[time.zone.timezone]]</a>
+#### Overview <a id="time.zone.overview">[[time.zone.overview]]</a>
+``` cpp
+namespace std::chrono {
+  class time_zone {
+  public:
+    time_zone(time_zone&&) = default;
+    time_zone& operator=(time_zone&&) = default;
+    // unspecified additional constructors
+    string_view name() const noexcept;
+    template<class Duration> sys_info   get_info(const sys_time<Duration>& st)   const;
+    template<class Duration> local_info get_info(const local_time<Duration>& tp) const;
+    template<class Duration>
+      sys_time<common_type_t<Duration, seconds>>
+        to_sys(const local_time<Duration>& tp) const;
+    template<class Duration>
+      sys_time<common_type_t<Duration, seconds>>
+        to_sys(const local_time<Duration>& tp, choose z) const;
+    template<class Duration>
+      local_time<common_type_t<Duration, seconds>>
+        to_local(const sys_time<Duration>& tp) const;
+  };
+}
+```
+A `time_zone` represents all time zone transitions for a specific
+geographic area. `time_zone` construction is unspecified, and performed
+as part of database initialization.
+[*Note 1*: `const time_zone` objects can be accessed via functions such
+as `locate_zone`. — *end note*]
+#### Member functions <a id="time.zone.members">[[time.zone.members]]</a>
+``` cpp
+string_view name() const noexcept;
+```
+*Returns:* The name of the `time_zone`.
+[*Example 1*: `"America/New_York"`. — *end example*]
+``` cpp
+template<class Duration>
+  sys_info get_info(const sys_time<Duration>& st) const;
+```
+*Returns:* A `sys_info` `i` for which `st` is in the range \[`i.begin`,
+`i.end`).
+``` cpp
+template<class Duration>
+  local_info get_info(const local_time<Duration>& tp) const;
+```
+*Returns:* A `local_info` for `tp`.
+``` cpp
+template<class Duration>
+  sys_time<common_type_t<Duration, seconds>>
+    to_sys(const local_time<Duration>& tp) const;
+```
+*Returns:* A `sys_time` that is at least as fine as `seconds`, and will
+be finer if the argument `tp` has finer precision. This `sys_time` is
+the UTC equivalent of `tp` according to the rules of this `time_zone`.
+*Throws:* If the conversion from `tp` to a `sys_time` is ambiguous,
+throws `ambiguous_local_time`. If the `tp` represents a non-existent
+time between two UTC `time_points`, throws `nonexistent_local_time`.
+``` cpp
+template<class Duration>
+  sys_time<common_type_t<Duration, seconds>>
+    to_sys(const local_time<Duration>& tp, choose z) const;
+```
+*Returns:* A `sys_time` that is at least as fine as `seconds`, and will
+be finer if the argument `tp` has finer precision. This `sys_time` is
+the UTC equivalent of `tp` according to the rules of this `time_zone`.
+If the conversion from `tp` to a `sys_time` is ambiguous, returns the
+earlier `sys_time` if `z == choose::earliest`, and returns the later
+`sys_time` if `z == choose::latest`. If the `tp` represents a
+non-existent time between two UTC `time_points`, then the two UTC
+`time_points` will be the same, and that UTC `time_point` will be
+returned.
+``` cpp
+template<class Duration>
+  local_time<common_type_t<Duration, seconds>>
+    to_local(const sys_time<Duration>& tp) const;
+```
+*Returns:* The `local_time` associated with `tp` and this `time_zone`.
+#### Non-member functions <a id="time.zone.nonmembers">[[time.zone.nonmembers]]</a>
+``` cpp
+bool operator==(const time_zone& x, const time_zone& y) noexcept;
+```
+*Returns:* `x.name() == y.name()`.
+``` cpp
+strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;
+```
+*Returns:* `x.name() <=> y.name()`.
+### Class template `zoned_traits` <a id="time.zone.zonedtraits">[[time.zone.zonedtraits]]</a>
+``` cpp
+namespace std::chrono {
+  template<class T> struct zoned_traits {};
+}
+```
+`zoned_traits` provides a means for customizing the behavior of
+`zoned_time<Duration, TimeZonePtr>` for the `zoned_time` default
+constructor, and constructors taking `string_view`. A specialization for
+`const time_zone*` is provided by the implementation:
+``` cpp
+namespace std::chrono {
+  template<> struct zoned_traits<const time_zone*> {
+    static const time_zone* default_zone();
+    static const time_zone* locate_zone(string_view name);
+  };
+}
+```
+``` cpp
+static const time_zone* default_zone();
+```
+*Returns:* `std::chrono::locate_zone("UTC")`.
+``` cpp
+static const time_zone* locate_zone(string_view name);
+```
+*Returns:* `std::chrono::locate_zone(name)`.
+### Class template `zoned_time` <a id="time.zone.zonedtime">[[time.zone.zonedtime]]</a>
+#### Overview <a id="time.zone.zonedtime.overview">[[time.zone.zonedtime.overview]]</a>
+``` cpp
+namespace std::chrono {
+  template<class Duration, class TimeZonePtr = const time_zone*>
+  class zoned_time {
+  public:
+    using duration = common_type_t<Duration, seconds>;
+  private:
+    TimeZonePtr        zone_;                   // exposition only
+    sys_time<duration> tp_;                     // exposition only
+    using traits = zoned_traits<TimeZonePtr>;   // exposition only
+  public:
+    zoned_time();
+    zoned_time(const zoned_time&) = default;
+    zoned_time& operator=(const zoned_time&) = default;
+    zoned_time(const sys_time<Duration>& st);
+    explicit zoned_time(TimeZonePtr z);
+    explicit zoned_time(string_view name);
+    template<class Duration2>
+      zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt);
+    zoned_time(TimeZonePtr z,    const sys_time<Duration>& st);
+    zoned_time(string_view name, const sys_time<Duration>& st);
+    zoned_time(TimeZonePtr z,    const local_time<Duration>& tp);
+    zoned_time(string_view name, const local_time<Duration>& tp);
+    zoned_time(TimeZonePtr z,    const local_time<Duration>& tp, choose c);
+    zoned_time(string_view name, const local_time<Duration>& tp, choose c);
+    template<class Duration2, class TimeZonePtr2>
+      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt);
+    template<class Duration2, class TimeZonePtr2>
+      zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
+    template<class Duration2, class TimeZonePtr2>
+      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt);
+    template<class Duration2, class TimeZonePtr2>
+      zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
+    zoned_time& operator=(const sys_time<Duration>& st);
+    zoned_time& operator=(const local_time<Duration>& ut);
+    operator sys_time<duration>() const;
+    explicit operator local_time<duration>() const;
+    TimeZonePtr          get_time_zone()  const;
+    local_time<duration> get_local_time() const;
+    sys_time<duration>   get_sys_time()   const;
+    sys_info             get_info()       const;
+  };
+  zoned_time() -> zoned_time<seconds>;
+  template<class Duration>
+    zoned_time(sys_time<Duration>)
+      -> zoned_time<common_type_t<Duration, seconds>>;
+  template<class TimeZonePtrOrName>
+    using time-zone-representation =        // exposition only
+      conditional_t<is_convertible_v<TimeZonePtrOrName, string_view>,
+                    const time_zone*,
+                    remove_cvref_t<TimeZonePtrOrName>>;
+  template<class TimeZonePtrOrName>
+    zoned_time(TimeZonePtrOrName&&)
+      -> zoned_time<seconds, time-zone-representation<TimeZonePtrOrName>>;
+  template<class TimeZonePtrOrName, class Duration>
+    zoned_time(TimeZonePtrOrName&&, sys_time<Duration>)
+      -> zoned_time<common_type_t<Duration, seconds>,
+                    time-zone-representation<TimeZonePtrOrName>>;
+  template<class TimeZonePtrOrName, class Duration>
+    zoned_time(TimeZonePtrOrName&&, local_time<Duration>,
+               choose = choose::earliest)
+      -> zoned_time<common_type_t<Duration, seconds>,
+                    time-zone-representation<TimeZonePtrOrName>>;
+  template<class Duration, class TimeZonePtrOrName, class TimeZonePtr2>
+    zoned_time(TimeZonePtrOrName&&, zoned_time<Duration, TimeZonePtr2>,
+               choose = choose::earliest)
+      -> zoned_time<common_type_t<Duration, seconds>,
+                    time-zone-representation<TimeZonePtrOrName>>;
+}
+```
+`zoned_time` represents a logical pairing of a `time_zone` and a
+`time_point` with precision `Duration`. `zoned_time<Duration>` maintains
+the invariant that it always refers to a valid time zone and represents
+a point in time that exists and is not ambiguous in that time zone.
+If `Duration` is not a specialization of `chrono::duration`, the program
+is ill-formed.
+Every constructor of `zoned_time` that accepts a `string_view` as its
+first parameter does not participate in class template argument
+deduction [[over.match.class.deduct]].
+#### Constructors <a id="time.zone.zonedtime.ctor">[[time.zone.zonedtime.ctor]]</a>
+``` cpp
+zoned_time();
+```
+*Constraints:* `traits::default_zone()` is a well-formed expression.
+*Effects:* Initializes `zone_` with `traits::default_zone()` and default
+constructs `tp_`.
+``` cpp
+zoned_time(const sys_time<Duration>& st);
+```
+*Constraints:* `traits::default_zone()` is a well-formed expression.
+*Effects:* Initializes `zone_` with `traits::default_zone()` and `tp_`
+with `st`.
+``` cpp
+explicit zoned_time(TimeZonePtr z);
+```
+*Preconditions:* `z` refers to a time zone.
+*Effects:* Initializes `zone_` with `std::move(z)` and default
+constructs `tp_`.
+``` cpp
+explicit zoned_time(string_view name);
+```
+*Constraints:* `traits::locate_zone(string_view{})` is a well-formed
+expression and `zoned_time` is constructible from the return type of
+`traits::locate_zone(string_view{})`.
+*Effects:* Initializes `zone_` with `traits::locate_zone(name)` and
+default constructs `tp_`.
+``` cpp
+template<class Duration2>
+  zoned_time(const zoned_time<Duration2, TimeZonePtr>& y);
+```
+*Constraints:*
+`is_convertible_v<sys_time<Duration2>, sys_time<Duration>>` is `true`.
+*Effects:* Initializes `zone_` with `y.zone_` and `tp_` with `y.tp_`.
+``` cpp
+zoned_time(TimeZonePtr z, const sys_time<Duration>& st);
+```
+*Preconditions:* `z` refers to a time zone.
+*Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with `st`.
+``` cpp
+zoned_time(string_view name, const sys_time<Duration>& st);
+```
+*Constraints:* `zoned_time` is constructible from the return type of
+`traits::locate_zone(name)` and `st`.
+*Effects:* Equivalent to construction with
+`{traits::locate_zone(name), st}`.
+``` cpp
+zoned_time(TimeZonePtr z, const local_time<Duration>& tp);
+```
+*Preconditions:* `z` refers to a time zone.
+*Constraints:*
+``` cpp
+is_convertible_v<
+  decltype(declval<TimeZonePtr&>()->to_sys(local_time<Duration>{})),
+  sys_time<duration>>
+```
+is `true`.
+*Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
+`zone_->to_sys(tp)`.
+``` cpp
+zoned_time(string_view name, const local_time<Duration>& tp);
+```
+*Constraints:* `zoned_time` is constructible from the return type of
+`traits::locate_zone(name)` and `tp`.
+*Effects:* Equivalent to construction with
+`{traits::locate_zone(name), tp}`.
+``` cpp
+zoned_time(TimeZonePtr z, const local_time<Duration>& tp, choose c);
+```
+*Preconditions:* `z` refers to a time zone.
+*Constraints:*
+``` cpp
+is_convertible_v<
+  decltype(declval<TimeZonePtr&>()->to_sys(local_time<Duration>{}, choose::earliest)),
+  sys_time<duration>>
+```
+is `true`.
+*Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
+`zone_->to_sys(tp, c)`.
+``` cpp
+zoned_time(string_view name, const local_time<Duration>& tp, choose c);
+```
+*Constraints:* `zoned_time` is constructible from the return type of
+`traits::locate_zone(name)`, `local_time<Duration>`, and `choose`.
+*Effects:* Equivalent to construction with
+`{traits::locate_zone(name), tp, c}`.
+``` cpp
+template<class Duration2, class TimeZonePtr2>
+  zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& y);
+```
+*Constraints:*
+`is_convertible_v<sys_time<Duration2>, sys_time<Duration>>` is `true`.
+*Preconditions:* `z` refers to a valid time zone.
+*Effects:* Initializes `zone_` with `std::move(z)` and `tp_` with
+`y.tp_`.
+``` cpp
+template<class Duration2, class TimeZonePtr2>
+  zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& y, choose);
+```
+*Constraints:*
+`is_convertible_v<sys_time<Duration2>, sys_time<Duration>>` is `true`.
+*Preconditions:* `z` refers to a valid time zone.
+*Effects:* Equivalent to construction with `{z, y}`.
+[*Note 1*: The `choose` parameter has no effect. — *end note*]
+``` cpp
+template<class Duration2, class TimeZonePtr2>
+  zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& y);
+```
+*Constraints:* `zoned_time` is constructible from the return type of
+`traits::locate_zone(name)` and the type
+`zoned_time<Duration2, TimeZonePtr2>`.
+*Effects:* Equivalent to construction with
+`{traits::locate_zone(name), y}`.
+``` cpp
+template<class Duration2, class TimeZonePtr2>
+  zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& y, choose c);
+```
+*Constraints:* `zoned_time` is constructible from the return type of
+`traits::locate_zone(name)`, the type
+`zoned_time<Duration2, TimeZonePtr2>`, and the type `choose`.
+*Effects:* Equivalent to construction with
+`{traits::locate_zone(name), y, c}`.
+[*Note 2*: The `choose` parameter has no effect. — *end note*]
+#### Member functions <a id="time.zone.zonedtime.members">[[time.zone.zonedtime.members]]</a>
+``` cpp
+zoned_time& operator=(const sys_time<Duration>& st);
+```
+*Effects:* After assignment, `get_sys_time() == st`. This assignment has
+no effect on the return value of `get_time_zone()`.
+*Returns:* `*this`.
+``` cpp
+zoned_time& operator=(const local_time<Duration>& lt);
+```
+*Effects:* After assignment, `get_local_time() == lt`. This assignment
+has no effect on the return value of `get_time_zone()`.
+*Returns:* `*this`.
+``` cpp
+operator sys_time<duration>() const;
+```
+*Returns:* `get_sys_time()`.
+``` cpp
+explicit operator local_time<duration>() const;
+```
+*Returns:* `get_local_time()`.
+``` cpp
+TimeZonePtr get_time_zone() const;
+```
+*Returns:* `zone_`.
+``` cpp
+local_time<duration> get_local_time() const;
+```
+*Returns:* `zone_->to_local(tp_)`.
+``` cpp
+sys_time<duration> get_sys_time() const;
+```
+*Returns:* `tp_`.
+``` cpp
+sys_info get_info() const;
+```
+*Returns:* `zone_->get_info(tp_)`.
+#### Non-member functions <a id="time.zone.zonedtime.nonmembers">[[time.zone.zonedtime.nonmembers]]</a>
+``` cpp
+template<class Duration1, class Duration2, class TimeZonePtr>
+  bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
+                  const zoned_time<Duration2, TimeZonePtr>& y);
+```
+*Returns:* `x.zone_ == y.zone_ && x.tp_ == y.tp_`.
+``` cpp
+template<class charT, class traits, class Duration, class TimeZonePtr>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os,
+               const zoned_time<Duration, TimeZonePtr>& t);
+```
+*Effects:* Streams the value returned from `t.get_local_time()` to `os`
+using the format `"%F %T %Z"`.
+*Returns:* `os`.
+### Class `leap_second` <a id="time.zone.leap">[[time.zone.leap]]</a>
+#### Overview <a id="time.zone.leap.overview">[[time.zone.leap.overview]]</a>
+``` cpp
+namespace std::chrono {
+  class leap_second {
+  public:
+    leap_second(const leap_second&)            = default;
+    leap_second& operator=(const leap_second&) = default;
+    // unspecified additional constructors
+    constexpr sys_seconds date() const noexcept;
+    constexpr seconds value() const noexcept;
+  };
+}
+```
+Objects of type `leap_second` representing the date and value of the
+leap second insertions are constructed and stored in the time zone
+database when initialized.
+[*Example 1*:
+``` cpp
+for (auto& l : get_tzdb().leap_seconds)
+  if (l <= 2018y/March/17d)
+    cout << l.date() << ": " << l.value() << '\n';
+```
+Produces the output:
+``` cpp
+1972-07-01 00:00:00: 1s
+1973-01-01 00:00:00: 1s
+1974-01-01 00:00:00: 1s
+1975-01-01 00:00:00: 1s
+1976-01-01 00:00:00: 1s
+1977-01-01 00:00:00: 1s
+1978-01-01 00:00:00: 1s
+1979-01-01 00:00:00: 1s
+1980-01-01 00:00:00: 1s
+1981-07-01 00:00:00: 1s
+1982-07-01 00:00:00: 1s
+1983-07-01 00:00:00: 1s
+1985-07-01 00:00:00: 1s
+1988-01-01 00:00:00: 1s
+1990-01-01 00:00:00: 1s
+1991-01-01 00:00:00: 1s
+1992-07-01 00:00:00: 1s
+1993-07-01 00:00:00: 1s
+1994-07-01 00:00:00: 1s
+1996-01-01 00:00:00: 1s
+1997-07-01 00:00:00: 1s
+1999-01-01 00:00:00: 1s
+2006-01-01 00:00:00: 1s
+2009-01-01 00:00:00: 1s
+2012-07-01 00:00:00: 1s
+2015-07-01 00:00:00: 1s
+2017-01-01 00:00:00: 1s
+```
+— *end example*]
+#### Member functions <a id="time.zone.leap.members">[[time.zone.leap.members]]</a>
+``` cpp
+constexpr sys_seconds date() const noexcept;
+```
+*Returns:* The date and time at which the leap second was inserted.
+``` cpp
+constexpr seconds value() const noexcept;
+```
+*Returns:* `+1s` to indicate a positive leap second or `-1s` to indicate
+a negative leap second.
+[*Note 1*: All leap seconds inserted up through 2019 were positive leap
+seconds. — *end note*]
+#### Non-member functions <a id="time.zone.leap.nonmembers">[[time.zone.leap.nonmembers]]</a>
+``` cpp
+constexpr bool operator==(const leap_second& x, const leap_second& y) noexcept;
+```
+*Returns:* `x.date() == y.date()`.
+``` cpp
+constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y) noexcept;
+```
+*Returns:* `x.date() <=> y.date()`.
+``` cpp
+template<class Duration>
+  constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y) noexcept;
+```
+*Returns:* `x.date() == y`.
+``` cpp
+template<class Duration>
+  constexpr bool operator<(const leap_second& x, const sys_time<Duration>& y) noexcept;
+```
+*Returns:* `x.date() < y`.
+``` cpp
+template<class Duration>
+  constexpr bool operator<(const sys_time<Duration>& x, const leap_second& y) noexcept;
+```
+*Returns:* `x < y.date()`.
+``` cpp
+template<class Duration>
+  constexpr bool operator>(const leap_second& x, const sys_time<Duration>& y) noexcept;
+```
+*Returns:* `y < x`.
+``` cpp
+template<class Duration>
+  constexpr bool operator>(const sys_time<Duration>& x, const leap_second& y) noexcept;
+```
+*Returns:* `y < x`.
+``` cpp
+template<class Duration>
+  constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y) noexcept;
+```
+*Returns:* `!(y < x)`.
+``` cpp
+template<class Duration>
+  constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y) noexcept;
+```
+*Returns:* `!(y < x)`.
+``` cpp
+template<class Duration>
+  constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y) noexcept;
+```
+*Returns:* `!(x < y)`.
+``` cpp
+template<class Duration>
+  constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y) noexcept;
+```
+*Returns:* `!(x < y)`.
+``` cpp
+template<class Duration>
+  requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
+  constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y) noexcept;
+```
+*Returns:* `x.date() <=> y`.
+### Class `time_zone_link` <a id="time.zone.link">[[time.zone.link]]</a>
+#### Overview <a id="time.zone.link.overview">[[time.zone.link.overview]]</a>
+``` cpp
+namespace std::chrono {
+  class time_zone_link {
+  public:
+    time_zone_link(time_zone_link&&)            = default;
+    time_zone_link& operator=(time_zone_link&&) = default;
+    // unspecified additional constructors
+    string_view name()   const noexcept;
+    string_view target() const noexcept;
+  };
+}
+```
+A `time_zone_link` specifies an alternative name for a `time_zone`.
+`time_zone_link`s are constructed when the time zone database is
+initialized.
+#### Member functions <a id="time.zone.link.members">[[time.zone.link.members]]</a>
+``` cpp
+string_view name() const noexcept;
+```
+*Returns:* The alternative name for the time zone.
+``` cpp
+string_view target() const noexcept;
+```
+*Returns:* The name of the `time_zone` for which this `time_zone_link`
+provides an alternative name.
+#### Non-member functions <a id="time.zone.link.nonmembers">[[time.zone.link.nonmembers]]</a>
+``` cpp
+bool operator==(const time_zone_link& x, const time_zone_link& y) noexcept;
+```
+*Returns:* `x.name() == y.name()`.
+``` cpp
+strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y) noexcept;
+```
+*Returns:* `x.name() <=> y.name()`.

Diff to HTML by rtfpessoa