[time.cal.month] - C++17 → C++20

Files changed (1) hide show

tmp/tmp2_ifewuk/{from.md → to.md} +199 -0

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

	@@ -0,0 +1,199 @@

+### Class `month` <a id="time.cal.month">[[time.cal.month]]</a>
+#### Overview <a id="time.cal.month.overview">[[time.cal.month.overview]]</a>
+``` cpp
+namespace std::chrono {
+  class month {
+    unsigned char m_;           // exposition only
+  public:
+    month() = default;
+    constexpr explicit month(unsigned m) noexcept;
+    constexpr month& operator++()    noexcept;
+    constexpr month  operator++(int) noexcept;
+    constexpr month& operator--()    noexcept;
+    constexpr month  operator--(int) noexcept;
+    constexpr month& operator+=(const months& m) noexcept;
+    constexpr month& operator-=(const months& m) noexcept;
+    constexpr explicit operator unsigned() const noexcept;
+    constexpr bool ok() const noexcept;
+  };
+}
+```
+`month` represents a month of a year. It normally holds values in the
+range 1 to 12, but may hold non-negative values outside this range. It
+can be constructed with any `unsigned` value, which will be subsequently
+truncated to fit into `month`’s unspecified internal storage. `month`
+meets the *Cpp17EqualityComparable* ([[cpp17.equalitycomparable]]) and
+*Cpp17LessThanComparable* ([[cpp17.lessthancomparable]]) requirements,
+and participates in basic arithmetic with `months` objects, which
+represent a difference between two `month` objects.
+`month` is a trivially copyable and standard-layout class type.
+#### Member functions <a id="time.cal.month.members">[[time.cal.month.members]]</a>
+``` cpp
+constexpr explicit month(unsigned m) noexcept;
+```
+*Effects:* Initializes `m_` with `m`. The value held is unspecified if
+`m` is not in the range \[`0`, `255`\].
+``` cpp
+constexpr month& operator++() noexcept;
+```
+*Effects:* `*this += months{1}`.
+*Returns:* `*this`.
+``` cpp
+constexpr month operator++(int) noexcept;
+```
+*Effects:* `++(*this)`.
+*Returns:* A copy of `*this` as it existed on entry to this member
+function.
+``` cpp
+constexpr month& operator--() noexcept;
+```
+*Effects:* `*this -= months{1}`.
+*Returns:* `*this`.
+``` cpp
+constexpr month operator--(int) noexcept;
+```
+*Effects:* `–(*this)`.
+*Returns:* A copy of `*this` as it existed on entry to this member
+function.
+``` cpp
+constexpr month& operator+=(const months& m) noexcept;
+```
+*Effects:* `*this = *this + m`.
+*Returns:* `*this`.
+``` cpp
+constexpr month& operator-=(const months& m) noexcept;
+```
+*Effects:* `*this = *this - m`.
+*Returns:* `*this`.
+``` cpp
+constexpr explicit operator unsigned() const noexcept;
+```
+*Returns:* `m_`.
+``` cpp
+constexpr bool ok() const noexcept;
+```
+*Returns:* `1 <= m_ && m_ <= 12`.
+#### Non-member functions <a id="time.cal.month.nonmembers">[[time.cal.month.nonmembers]]</a>
+``` cpp
+constexpr bool operator==(const month& x, const month& y) noexcept;
+```
+*Returns:* `unsigned{x} == unsigned{y}`.
+``` cpp
+constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
+```
+*Returns:* `unsigned{x} <=> unsigned{y}`.
+``` cpp
+constexpr month operator+(const month& x, const months& y) noexcept;
+```
+*Returns:*
+``` cpp
+month{modulo(static_cast<long long>(unsigned{x}) + (y.count() - 1), 12) + 1}
+```
+where `modulo(n, 12)` computes the remainder of `n` divided by 12 using
+Euclidean division.
+[*Note 1*: Given a divisor of 12, Euclidean division truncates towards
+negative infinity and always produces a remainder in the range of \[`0`,
+`11`\]. Assuming no overflow in the signed summation, this operation
+results in a `month` holding a value in the range \[`1`, `12`\] even if
+`!x.ok()`. — *end note*]
+[*Example 1*: `February + months{11} == January`. — *end example*]
+``` cpp
+constexpr month operator+(const months& x, const month& y) noexcept;
+```
+*Returns:* `y + x`.
+``` cpp
+constexpr month operator-(const month& x, const months& y) noexcept;
+```
+*Returns:* `x + -y`.
+``` cpp
+constexpr months operator-(const month& x, const month& y) noexcept;
+```
+*Returns:* If `x.ok() == true` and `y.ok() == true`, returns a value `m`
+in the range \[`months{0}`, `months{11}`\] satisfying `y + m == x`.
+Otherwise the value returned is unspecified.
+[*Example 2*: `January - February == months{11}`. — *end example*]
+``` cpp
+template<class charT, class traits>
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const month& m);
+```
+*Effects:* Equivalent to:
+``` cpp
+return os << (m.ok() ?
+  format(os.getloc(), STATICALLY-WIDEN<charT>("{:%b}"), m) :
+  format(os.getloc(), STATICALLY-WIDEN<charT>("{} is not a valid month"),
+         static_cast<unsigned>(m)));
+```
+``` cpp
+template<class charT, class traits, class Alloc = allocator<charT>>
+  basic_istream<charT, traits>&
+    from_stream(basic_istream<charT, traits>& is, const charT* fmt,
+                month& m, basic_string<charT, traits, Alloc>* abbrev = nullptr,
+                minutes* offset = nullptr);
+```
+*Effects:* Attempts to parse the input stream `is` into the `month` `m`
+using the format flags given in the NTCTS `fmt` as specified in
+[[time.parse]]. If the parse fails to decode a valid month,
+`is.setstate(ios_base::failbit)` is called and `m` 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`.

Diff to HTML by rtfpessoa