[category.monetary] - C++17 → C++20

Files changed (1) hide show

tmp/tmpnf9rsqdm/{from.md → to.md} +70 -54

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

@@ -3,14 +3,13 @@
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
-specializations required in Tables  [[tab:localization.category.facets]]
-and  [[tab:localization.required.specializations]] (
-[[locale.category]]). Their members use their `ios_base&`,
-`ios_base::iostate&`, and `fill` arguments as described in
 [[locale.categories]], and the `moneypunct<>` and `ctype<>` facets, to
 determine formatting details.
 #### Class template `money_get` <a id="locale.money.get">[[locale.money.get]]</a>
@@ -42,31 +41,28 @@ namespace std {
                                ios_base::iostate& err, string_type& digits) const;
     };
 }
 ```
-##### `money_get` members <a id="locale.money.get.members">[[locale.money.get.members]]</a>
 ``` cpp
-iter_type get(iter_type s, iter_type end, bool intl,
-              ios_base& f, ios_base::iostate& err,
-              long double& quant) const;
-iter_type get(s, iter_type end, bool intl, ios_base&f,
               ios_base::iostate& err, string_type& quant) const;
 ```
 *Returns:* `do_get(s, end, intl, f, err, quant)`.
-##### `money_get` virtual functions <a id="locale.money.get.virtuals">[[locale.money.get.virtuals]]</a>
 ``` cpp
-iter_type do_get(iter_type s, iter_type end, bool intl,
-                 ios_base& str, ios_base::iostate& err,
-                 long double& units) const;
-iter_type do_get(iter_type s, iter_type end, bool intl,
-                 ios_base& str, ios_base::iostate& err,
-                 string_type& digits) const;
 ```
 *Effects:* Reads characters from `s` to parse and construct a monetary
 value according to the format specified by a `moneypunct<charT, Intl>`
 facet reference `mp` and the character mapping specified by a
@@ -76,11 +72,11 @@ does not change `err`; otherwise, sets `err` to `(err|str.failbit)`, or
 `(err|str.failbit|str.eofbit)` if no more characters are available, and
 does not change `units` or `digits`. Uses the pattern returned by
 `mp.neg_format()` to parse all values. The result is returned as an
 integral value stored in `units` or as a sequence of digits possibly
 preceded by a minus sign (as produced by `ct.widen(c)` where `c` is
-`’-’` or in the range from `’0’` through `’9’`, inclusive) stored in
 `digits`.
 [*Example 1*: The sequence `$1,056.23` in a common United States locale
 would yield, for `units`, `105623`, or, for `digits`,
 `"105623"`. — *end example*]
@@ -95,13 +91,13 @@ Where `money_base::space` or `money_base::none` appears as the last
 element in the format pattern, no white space is consumed. Otherwise,
 where `money_base::space` appears in any of the initial elements of the
 format pattern, at least one white space character is required. Where
 `money_base::none` appears in any of the initial elements of the format
 pattern, white space is allowed but not required. If
-`(str.flags() & str.showbase)` is false, the currency symbol is optional
-and is consumed only if other characters are needed to complete the
-format; otherwise, the currency symbol is required.
 If the first character (if any) in the string `pos` returned by
 `mp.positive_sign()` or the string `neg` returned by
 `mp.negative_sign()` is recognized in the position indicated by `sign`
 in the format pattern, it is consumed and any remaining characters in
@@ -173,22 +169,20 @@ namespace std {
                                const string_type& digits) const;
     };
 }
 ```
-##### `money_put` members <a id="locale.money.put.members">[[locale.money.put.members]]</a>
 ``` cpp
-iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
-              long double quant) const;
-iter_type put(iter_type s, bool intl, ios_base& f, char_type fill,
-              const string_type& quant) const;
 ```
 *Returns:* `do_put(s, intl, f, loc, quant)`.
-##### `money_put` virtual functions <a id="locale.money.put.virtuals">[[locale.money.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, bool intl, ios_base& str,
                  char_type fill, long double units) const;
 iter_type do_put(iter_type s, bool intl, ios_base& str,
@@ -282,11 +276,11 @@ namespace std {
 ```
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
-value `static_cast<part>(p.field[i])` determines the `i`th component of
 the format[^21] In the `field` member of a `pattern` object, each value
 `symbol`, `sign`, `value`, and either `space` or `none` appears exactly
 once. The value `none`, if present, is not first; the value `space`, if
 present, is neither first nor last.
@@ -302,44 +296,57 @@ required. Any remaining characters of the sign sequence are required
 after all other format components. Where `value` appears, the absolute
 numeric monetary value is required.
 The format of the numeric monetary value is a decimal number:
-``` cpp
-value ::= units [ decimal-point [ digits ]] |
     decimal-point digits
 ```
 if `frac_digits()` returns a positive value, or
-``` cpp
-value ::= units
 ```
-otherwise. The symbol `decimal-point` indicates the character returned
-by `decimal_point()`. The other symbols are defined as follows:
-``` cpp
-units ::= digits [ thousands-sep units ]
-digits ::= adigit [ digits ]
 ```
-In the syntax specification, the symbol `adigit` is any of the values
-`ct.widen(c)` for `c` in the range `'0'` through `'9'`, inclusive, and
 `ct` is a reference of type `const ctype<charT>&` obtained as described
-in the definitions of `money_get<>` and `money_put<>`. The symbol
-`thousands-sep` is the character returned by `thousands_sep()`. The
-space character used is the value `ct.widen(' ')`. White space
-characters are those characters `c` for which `ci.is(space, c)` returns
-`true`. The number of digits required after the decimal point (if any)
-is exactly the value returned by `frac_digits()`.
 The placement of thousands-separator characters (if any) is determined
 by the value returned by `grouping()`, defined identically as the member
 `numpunct<>::do_grouping()`.
-##### `moneypunct` members <a id="locale.moneypunct.members">[[locale.moneypunct.members]]</a>
 ``` cpp
 charT        decimal_point() const;
 charT        thousands_sep() const;
 string       grouping()      const;
@@ -352,11 +359,11 @@ pattern      neg_format()    const;
 ```
 Each of these functions `F` returns the result of calling the
 corresponding virtual member function `do_F()`.
-##### `moneypunct` virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` cpp
 charT do_decimal_point() const;
 ```
@@ -379,39 +386,47 @@ to, the result of `numpunct<charT>::do_grouping()`.[^24]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
-*Returns:* A string to use as the currency identifier symbol.[^25]
 ``` cpp
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
-positive monetary value;[^26] `do_negative_sign()` returns the string to
 use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
-any.[^27]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 *Returns:* The specializations required in
-Table  [[tab:localization.required.specializations]] ([[locale.category]]),
-namely `moneypunct<char>`, `moneypunct<wchar_t>`,
-`moneypunct<char, true>`, and `moneypunct<wchar_t, true>`, return an
-object of type `pattern` initialized to
-`{ symbol, sign, none, value }`.[^28]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
@@ -421,10 +436,11 @@ namespace std {
       using pattern     = money_base::pattern;
       using string_type = basic_string<charT>;
       explicit moneypunct_byname(const char*, size_t refs = 0);
       explicit moneypunct_byname(const string&, size_t refs = 0);
     protected:
       ~moneypunct_byname();
     };
 }
 ```

 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
+specializations required in Tables  [[tab:locale.category.facets]] and
+[[tab:locale.spec]] [[locale.category]]. Their members use their
+`ios_base&`, `ios_base::iostate&`, and `fill` arguments as described in
 [[locale.categories]], and the `moneypunct<>` and `ctype<>` facets, to
 determine formatting details.
 #### Class template `money_get` <a id="locale.money.get">[[locale.money.get]]</a>
                                ios_base::iostate& err, string_type& digits) const;
     };
 }
 ```
+##### Members <a id="locale.money.get.members">[[locale.money.get.members]]</a>
 ``` cpp
+iter_type get(iter_type s, iter_type end, bool intl, ios_base& f,
+              ios_base::iostate& err, long double& quant) const;
+iter_type get(iter_type s, iter_type end, bool intl, ios_base& f,
               ios_base::iostate& err, string_type& quant) const;
 ```
 *Returns:* `do_get(s, end, intl, f, err, quant)`.
+##### Virtual functions <a id="locale.money.get.virtuals">[[locale.money.get.virtuals]]</a>
 ``` cpp
+iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
+                 ios_base::iostate& err, long double& units) const;
+iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
+                 ios_base::iostate& err, string_type& digits) const;
 ```
 *Effects:* Reads characters from `s` to parse and construct a monetary
 value according to the format specified by a `moneypunct<charT, Intl>`
 facet reference `mp` and the character mapping specified by a
 `(err|str.failbit|str.eofbit)` if no more characters are available, and
 does not change `units` or `digits`. Uses the pattern returned by
 `mp.neg_format()` to parse all values. The result is returned as an
 integral value stored in `units` or as a sequence of digits possibly
 preceded by a minus sign (as produced by `ct.widen(c)` where `c` is
+`’-’` or in the range from `’0’` through `’9’` (inclusive)) stored in
 `digits`.
 [*Example 1*: The sequence `$1,056.23` in a common United States locale
 would yield, for `units`, `105623`, or, for `digits`,
 `"105623"`. — *end example*]
 element in the format pattern, no white space is consumed. Otherwise,
 where `money_base::space` appears in any of the initial elements of the
 format pattern, at least one white space character is required. Where
 `money_base::none` appears in any of the initial elements of the format
 pattern, white space is allowed but not required. If
+`(str.flags() & str.showbase)` is `false`, the currency symbol is
+optional and is consumed only if other characters are needed to complete
+the format; otherwise, the currency symbol is required.
 If the first character (if any) in the string `pos` returned by
 `mp.positive_sign()` or the string `neg` returned by
 `mp.negative_sign()` is recognized in the position indicated by `sign`
 in the format pattern, it is consumed and any remaining characters in
                                const string_type& digits) const;
     };
 }
 ```
+##### Members <a id="locale.money.put.members">[[locale.money.put.members]]</a>
 ``` cpp
+iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, long double quant) const;
+iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, const string_type& quant) const;
 ```
 *Returns:* `do_put(s, intl, f, loc, quant)`.
+##### Virtual functions <a id="locale.money.put.virtuals">[[locale.money.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, bool intl, ios_base& str,
                  char_type fill, long double units) const;
 iter_type do_put(iter_type s, bool intl, ios_base& str,
 ```
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
+value `static_cast<part>(p.field[i])` determines the `i`ᵗʰ component of
 the format[^21] In the `field` member of a `pattern` object, each value
 `symbol`, `sign`, `value`, and either `space` or `none` appears exactly
 once. The value `none`, if present, is not first; the value `space`, if
 present, is neither first nor last.
 after all other format components. Where `value` appears, the absolute
 numeric monetary value is required.
 The format of the numeric monetary value is a decimal number:
+``` bnf
+value:
+    units fractionalₒₚₜ
     decimal-point digits
 ```
+``` bnf
+fractional:
+    decimal-point digitsₒₚₜ
+```
 if `frac_digits()` returns a positive value, or
+``` bnf
+value:
+    units
 ```
+otherwise. The symbol indicates the character returned by
+`decimal_point()`. The other symbols are defined as follows:
+``` bnf
+units:
+ digits
+    digits thousands-sep units
 ```
+``` bnf
+digits:
+    adigit digitsₒₚₜ
+```
+In the syntax specification, the symbol is any of the values
+`ct.widen(c)` for `c` in the range `'0'` through `'9'` (inclusive) and
 `ct` is a reference of type `const ctype<charT>&` obtained as described
+in the definitions of `money_get<>` and `money_put<>`. The symbol is the
+character returned by `thousands_sep()`. The space character used is the
+value `ct.widen(' ')`. White space characters are those characters `c`
+for which `ci.is(space, c)` returns `true`. The number of digits
+required after the decimal point (if any) is exactly the value returned
+by `frac_digits()`.
 The placement of thousands-separator characters (if any) is determined
 by the value returned by `grouping()`, defined identically as the member
 `numpunct<>::do_grouping()`.
+##### Members <a id="locale.moneypunct.members">[[locale.moneypunct.members]]</a>
 ``` cpp
 charT        decimal_point() const;
 charT        thousands_sep() const;
 string       grouping()      const;
 ```
 Each of these functions `F` returns the result of calling the
 corresponding virtual member function `do_F()`.
+##### Virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` cpp
 charT do_decimal_point() const;
 ```
 ``` cpp
 string_type do_curr_symbol() const;
 ```
+*Returns:* A string to use as the currency identifier symbol.
+[*Note 1*: For specializations where the second template parameter is
+`true`, this is typically four characters long: a three-letter code as
+specified by ISO 4217 followed by a space. — *end note*]
 ``` cpp
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
+positive monetary value;[^25] `do_negative_sign()` returns the string to
 use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
+any.[^26]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 *Returns:* The specializations required in
+[[locale.spec]][[locale.category]], namely
+- `moneypunct<char>`,
+- `moneypunct<wchar_t>`,
+- `moneypunct<char, true>`, and
+- `moneypunct<wchar_t, true>`,
+return an object of type `pattern` initialized to
+`{ symbol, sign, none, value }`.[^27]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
       using pattern     = money_base::pattern;
       using string_type = basic_string<charT>;
       explicit moneypunct_byname(const char*, size_t refs = 0);
       explicit moneypunct_byname(const string&, size_t refs = 0);
     protected:
       ~moneypunct_byname();
     };
 }
 ```

Diff to HTML by rtfpessoa