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

Files changed (1) hide show

tmp/tmp3z2cc2ng/{from.md → to.md} +363 -0

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

	@@ -0,0 +1,363 @@

+### 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`.

Diff to HTML by rtfpessoa