[localization] - C++11 → C++14

Files changed (1) hide show

tmp/tmp9jkdbcy9/{from.md → to.md} +70 -51

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

@@ -41,10 +41,11 @@ namespace std {
   template <class charT> bool isdigit (charT c, const locale& loc);
   template <class charT> bool ispunct (charT c, const locale& loc);
   template <class charT> bool isxdigit(charT c, const locale& loc);
   template <class charT> bool isalnum (charT c, const locale& loc);
   template <class charT> bool isgraph (charT c, const locale& loc);
   template <class charT> charT toupper(charT c, const locale& loc);
   template <class charT> charT tolower(charT c, const locale& loc);
   template <class Codecvt, class Elem = wchar_t,
     class Wide_alloc = std::allocator<Elem>,
     class Byte_alloc = std::allocator<char> > class wstring_convert;
@@ -72,21 +73,21 @@ namespace std {
   // [category.time], date and time:
   class time_base;
   template <class charT, class InputIterator = istreambuf_iterator<charT> >
     class time_get;
-  template <class charT, class InputIterator> = istreambuf_iterator<charT> >
     class time_get_byname;
-  template <class charT, class OutputIterator> = ostreambuf_iterator<charT> >
     class time_put;
-  template <class charT, class OutputIterator> = ostreambuf_iterator<charT> >
     class time_put_byname;
   // [category.monetary], money:
   class money_base;
-  template <class charT, class InputIterator = istreambuf_iterator<charT> > >  class money_get;
-  template <class charT, class OutputIterator = ostreambuf_iterator<charT> > > class money_put;
   template <class charT, bool Intl = false> class moneypunct;
   template <class charT, bool Intl = false> class moneypunct_byname;
   // [category.messages], message retrieval:
   class messages_base;
@@ -309,20 +310,20 @@ The provided implementation of members of facets `num_get<charT>` and
 `num_put<charT>` calls `use_facet <F> (l)` only for facet `F` of types
 `numpunct<charT>` and `ctype<charT>`, and for locale `l` the value
 obtained by calling member `getloc()` on the `ios_base&` argument to
 these functions.
-In declarations of facets, a template formal parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that satisfy the requirements of an Input
 Iterator or an Output Iterator, respectively (
-[[iterator.requirements]]). A template formal parameter with name `C`
 represents the set of types containing `char`, `wchar_t`, and any other
 implementation-defined character types that satisfy the requirements for
 a character on which any of the iostream components can be instantiated.
-A template formal parameter with name `International` represents the set
-of all possible specializations on a bool parameter.
 ##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
@@ -412,14 +413,10 @@ value for arguments of functions that take a `const locale&` argument.
 locale(const locale& other) noexcept;
 ```
 *Effects:* Constructs a locale which is a copy of `other`.
-*Effects:* Creates a copy of `other`, replacing the current value.
-*Returns:* `*this`
 ``` cpp
 explicit locale(const char* std_name);
 ```
 *Effects:* Constructs a locale using standard C locale names, e.g.,
@@ -479,10 +476,14 @@ arguments have names.
 ``` cpp
 const locale& operator=(const locale& other) noexcept;
 ```
 ``` cpp
 ~locale();
 ```
 A non-virtual destructor that throws no exceptions.
@@ -660,18 +661,17 @@ template <class charT> charT tolower(charT c, const locale& loc);
 ##### `string` conversions <a id="conversions.string">[[conversions.string]]</a>
 Class template `wstring_convert` performs conversions between a wide
 string and a byte string. It lets you specify a code conversion facet
 (like class template `codecvt`) to perform the conversions, without
-affecting any streams or locales. Say, for example, you have a code
-conversion facet called `codecvt_utf8` that you want to use to output to
-`cout` a UTF-8 multibyte sequence corresponding to a wide string, but
-you don’t want to alter the locale for `cout`. You can write something
-like:
 ``` cpp
-wstring_convert<codecvt_utf8<wchar_t>> myconv;
 std::string mbstring = myconv.to_bytes(L"Hello\n");
 std::cout << mbstring;
 ```
 ``` cpp
@@ -683,27 +683,30 @@ template<class Codecvt, class Elem = wchar_t,
     typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
     typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
     typedef typename Codecvt::state_type state_type;
     typedef typename wide_string::traits_type::int_type int_type;
-    wstring_convert(Codecvt *pcvt = new Codecvt);
     wstring_convert(Codecvt* pcvt, state_type state);
-    wstring_convert(const byte_string& byte_err,
                              const wide_string& wide_err = wide_string());
     ~wstring_convert();
     wide_string from_bytes(char byte);
     wide_string from_bytes(const char* ptr);
     wide_string from_bytes(const byte_string& str);
     wide_string from_bytes(const char* first, const char* last);
     byte_string to_bytes(Elem wchar);
     byte_string to_bytes(const Elem* wptr);
     byte_string to_bytes(const wide_string& wstr);
     byte_string to_bytes(const Elem* first, const Elem* last);
-    size_t converted() const;
     state_type state() const;
   private:
     byte_string byte_err_string;    // exposition only
     wide_string wide_err_string;    // exposition only
     Codecvt* cvtptr;                // exposition only
@@ -716,15 +719,14 @@ template<class Codecvt, class Elem = wchar_t,
 The class template describes an object that controls conversions between
 wide string objects of class `std::basic_string<Elem, char_traits<Elem>,
 Wide_alloc>` and byte string objects of class `std::\\basic_string<char,
 char_traits<char>, Byte_alloc>`. The class template defines the types
 `wide_string` and `byte_string` as synonyms for these two types.
-Conversion between a sequence of `Elem` values (stored in a wide_string
-object) and multibyte sequences (stored in a byte_string object) is
-performed by an object of class `Codecvt<Elem, char, std::mbstate_t>`,
-which meets the requirements of the standard code-conversion facet
-`std::codecvt<Elem,
 char, std::mbstate_t>`.
 An object of this class template stores:
 - `byte_err_string` — a byte string to display on errors
@@ -733,17 +735,18 @@ An object of this class template stores:
   freed when the `wstring_convert` object is destroyed)
 - `cvtstate` — a conversion state object
 - `cvtcount` — a conversion count
 ``` cpp
-typedef std::basic_string<char> byte_string;
 ```
-The type shall be a synonym for `std::basic_string<char>`
 ``` cpp
-size_t converted() const;
 ```
 *Returns:* `cvtcount`.
 ``` cpp
@@ -819,22 +822,25 @@ return the converted byte string. Otherwise, if the object was
 constructed with a byte-error string, the member function shall return
 the byte-error string. Otherwise, the member function shall throw an
 object of class `std::range_error`.
 ``` cpp
-typedef std::basic_string<Elem> wide_string;
 ```
-The type shall be a synonym for `std::basic_string<Elem>`.
 ``` cpp
-wstring_convert(Codecvt *pcvt = new Codecvt);
 wstring_convert(Codecvt* pcvt, state_type state);
-wstring_convert(const byte_string& byte_err,
     const wide_string& wide_err = wide_string());
 ```
 *Effects:* The first constructor shall store `pcvt` in `cvtptr` and
 default values in `cvtstate`, `byte_err_string`, and `wide_err_string`.
 The second constructor shall store `pcvt` in `cvtptr`, `state` in
 `cvtstate`, and default values in `byte_err_string` and
 `wide_err_string`; moreover the stored state shall be retained between
@@ -864,14 +870,19 @@ template<class Codecvt,
   class wbuffer_convert
     : public std::basic_streambuf<Elem, Tr> {
   public:
     typedef typename Codecvt::state_type state_type;
-    wbuffer_convert(std::streambuf *bytebuf = 0,
                              Codecvt* pcvt = new Codecvt,
                              state_type state = state_type());
     std::streambuf* rdbuf() const;
     std::streambuf* rdbuf(std::streambuf* bytebuf);
     state_type state() const;
@@ -885,13 +896,12 @@ template<class Codecvt,
 The class template describes a stream buffer that controls the
 transmission of elements of type `Elem`, whose character traits are
 described by the class `Tr`, to and from a byte stream buffer of type
 `std::streambuf`. Conversion between a sequence of `Elem` values and
-multibyte sequences is performed by an object of class
-`Codecvt<Elem, char, std::mbstate_t>`, which shall meet the requirements
-of the standard code-conversion facet
 `std::codecvt<Elem, char, std::mbstate_t>`.
 An object of this class template stores:
 - `bufptr` — a pointer to its underlying byte stream buffer
@@ -924,14 +934,16 @@ typedef typename Codecvt::state_type state_type;
 ```
 The type shall be a synonym for `Codecvt::state_type`.
 ``` cpp
-wbuffer_convert(std::streambuf *bytebuf = 0,
     Codecvt* pcvt = new Codecvt, state_type state = state_type());
 ```
 *Effects:* The constructor constructs a stream buffer object,
 initializes `bufptr` to `bytebuf`, initializes `cvtptr` to `pcvt`, and
 initializes `cvtstate` to `state`.
 ``` cpp
@@ -1495,19 +1507,20 @@ mapped between.
 The specializations required in Table
 [[tab:localization.category.facets]] ([[locale.category]]) convert the
 implementation-defined native character set.
 `codecvt<char, char, mbstate_t>` implements a degenerate conversion; it
 does not convert at all. The specialization `codecvt<char16_t,`
-`char, mbstate_t>` converts between the UTF-16 and UTF-8 encoding
-schemes, and the specialization `codecvt` `<char32_t, char, mbstate_t>`
-converts between the UTF-32 and UTF-8 encoding schemes.
 `codecvt<wchar_t,char,mbstate_t>` converts between the native character
 sets for narrow and wide characters. Specializations on `mbstate_t`
 perform conversion between encodings known to the library implementer.
 Other encodings can be converted by specializing on a user-defined
-`stateT` type. The `stateT` object can contain any state that is useful
-to communicate to or from the specialized `do_in` or `do_out` members.
 ##### `codecvt` members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
 result out(stateT& state,
@@ -2321,12 +2334,12 @@ iter_type do_put(iter_type out, ios_base& str, char_type fill,
 `do_put(out, str, fill,`
 `(int)val)`, otherwise obtains a string `s` as if by
 ``` cpp
 string_type s =
-  val ? use_facet<ctype<charT> >(loc).truename()
-    : use_facet<ctype<charT> >(loc).falsename();
 ```
 and then inserts each character `c` of `s` into `out` via `*out++ = c`
 and returns `out`.
@@ -2854,11 +2867,11 @@ recognized as part of a valid year identifier.
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, ios_base& f,
     ios_base::iostate& err, tm* t, char format, char modifier) const;
 ```
-*Requires:* `t` shall be dereferenceable.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
 or until it has extracted and assigned those `struct tm` members, and
 any remaining format characters, corresponding to a conversion directive
@@ -3437,11 +3450,11 @@ catalogs.
 ``` cpp
 namespace std {
   class messages_base {
   public:
-    typedef int catalog;
   };
   template <class charT>
   class messages : public locale::facet, public messages_base {
   public:
@@ -3738,25 +3751,31 @@ namespace std {
   template<class Elem, unsigned long Maxcode = 0x10ffff,
     codecvt_mode Mode = (codecvt_mode)0>
   class codecvt_utf8
     : public codecvt<Elem, char, mbstate_t> {
-    // unspecified
   };
   template<class Elem, unsigned long Maxcode = 0x10ffff,
     codecvt_mode Mode = (codecvt_mode)0>
   class codecvt_utf16
     : public codecvt<Elem, char, mbstate_t> {
-    // unspecified
   };
   template<class Elem, unsigned long Maxcode = 0x10ffff,
     codecvt_mode Mode = (codecvt_mode)0>
   class codecvt_utf8_utf16
     : public codecvt<Elem, char, mbstate_t> {
-    // unspecified
   };
 }
 ```
 For each of the three code conversion facets `codecvt_utf8`,

   template <class charT> bool isdigit (charT c, const locale& loc);
   template <class charT> bool ispunct (charT c, const locale& loc);
   template <class charT> bool isxdigit(charT c, const locale& loc);
   template <class charT> bool isalnum (charT c, const locale& loc);
   template <class charT> bool isgraph (charT c, const locale& loc);
+  template <class charT> bool isblank (charT c, const locale& loc);
   template <class charT> charT toupper(charT c, const locale& loc);
   template <class charT> charT tolower(charT c, const locale& loc);
   template <class Codecvt, class Elem = wchar_t,
     class Wide_alloc = std::allocator<Elem>,
     class Byte_alloc = std::allocator<char> > class wstring_convert;
   // [category.time], date and time:
   class time_base;
   template <class charT, class InputIterator = istreambuf_iterator<charT> >
     class time_get;
+  template <class charT, class InputIterator = istreambuf_iterator<charT> >
     class time_get_byname;
+  template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
     class time_put;
+  template <class charT, class OutputIterator = ostreambuf_iterator<charT> >
     class time_put_byname;
   // [category.monetary], money:
   class money_base;
+  template <class charT, class InputIterator = istreambuf_iterator<charT> >  class money_get;
+  template <class charT, class OutputIterator = ostreambuf_iterator<charT> > class money_put;
   template <class charT, bool Intl = false> class moneypunct;
   template <class charT, bool Intl = false> class moneypunct_byname;
   // [category.messages], message retrieval:
   class messages_base;
 `num_put<charT>` calls `use_facet <F> (l)` only for facet `F` of types
 `numpunct<charT>` and `ctype<charT>`, and for locale `l` the value
 obtained by calling member `getloc()` on the `ios_base&` argument to
 these functions.
+In declarations of facets, a template parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that satisfy the requirements of an Input
 Iterator or an Output Iterator, respectively (
+[[iterator.requirements]]). A template parameter with name `C`
 represents the set of types containing `char`, `wchar_t`, and any other
 implementation-defined character types that satisfy the requirements for
 a character on which any of the iostream components can be instantiated.
+A template parameter with name `International` represents the set of all
+possible specializations on a bool parameter.
 ##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
 locale(const locale& other) noexcept;
 ```
 *Effects:* Constructs a locale which is a copy of `other`.
 ``` cpp
 explicit locale(const char* std_name);
 ```
 *Effects:* Constructs a locale using standard C locale names, e.g.,
 ``` cpp
 const locale& operator=(const locale& other) noexcept;
 ```
+*Effects:* Creates a copy of `other`, replacing the current value.
+*Returns:* `*this`
 ``` cpp
 ~locale();
 ```
 A non-virtual destructor that throws no exceptions.
 ##### `string` conversions <a id="conversions.string">[[conversions.string]]</a>
 Class template `wstring_convert` performs conversions between a wide
 string and a byte string. It lets you specify a code conversion facet
 (like class template `codecvt`) to perform the conversions, without
+affecting any streams or locales. If you want to use the code conversion
+facet `codecvt_utf8` to output to `cout` a UTF-8 multibyte sequence
+corresponding to a wide string, but you don’t want to alter the locale
+for `cout`, you can write something like:
 ``` cpp
+wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
 std::string mbstring = myconv.to_bytes(L"Hello\n");
 std::cout << mbstring;
 ```
 ``` cpp
     typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
     typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
     typedef typename Codecvt::state_type state_type;
     typedef typename wide_string::traits_type::int_type int_type;
+ explicit wstring_convert(Codecvt* pcvt = new Codecvt);
     wstring_convert(Codecvt* pcvt, state_type state);
+ explicit wstring_convert(const byte_string& byte_err,
                              const wide_string& wide_err = wide_string());
     ~wstring_convert();
+    wstring_convert(const wstring_convert&) = delete;
+    wstring_convert& operator=(const wstring_convert&) = delete;
     wide_string from_bytes(char byte);
     wide_string from_bytes(const char* ptr);
     wide_string from_bytes(const byte_string& str);
     wide_string from_bytes(const char* first, const char* last);
     byte_string to_bytes(Elem wchar);
     byte_string to_bytes(const Elem* wptr);
     byte_string to_bytes(const wide_string& wstr);
     byte_string to_bytes(const Elem* first, const Elem* last);
+    size_t converted() const noexcept;
     state_type state() const;
   private:
     byte_string byte_err_string;    // exposition only
     wide_string wide_err_string;    // exposition only
     Codecvt* cvtptr;                // exposition only
 The class template describes an object that controls conversions between
 wide string objects of class `std::basic_string<Elem, char_traits<Elem>,
 Wide_alloc>` and byte string objects of class `std::\\basic_string<char,
 char_traits<char>, Byte_alloc>`. The class template defines the types
 `wide_string` and `byte_string` as synonyms for these two types.
+Conversion between a sequence of `Elem` values (stored in a
+`wide_string` object) and multibyte sequences (stored in a `byte_string`
+object) is performed by an object of class `Codecvt`, which meets the
+requirements of the standard code-conversion facet `std::codecvt<Elem,
 char, std::mbstate_t>`.
 An object of this class template stores:
 - `byte_err_string` — a byte string to display on errors
   freed when the `wstring_convert` object is destroyed)
 - `cvtstate` — a conversion state object
 - `cvtcount` — a conversion count
 ``` cpp
+typedef std::basic_string<char, char_traits<char>, Byte_alloc> byte_string;
 ```
+The type shall be a synonym for
+`std::basic_string<char, char_traits<char>, Byte_alloc>`
 ``` cpp
+size_t converted() const noexcept;
 ```
 *Returns:* `cvtcount`.
 ``` cpp
 constructed with a byte-error string, the member function shall return
 the byte-error string. Otherwise, the member function shall throw an
 object of class `std::range_error`.
 ``` cpp
+typedef std::basic_string<Elem, char_traits<Elem>, Wide_alloc> wide_string;
 ```
+The type shall be a synonym for
+`std::basic_string<Elem, char_traits<Elem>, Wide_alloc>`.
 ``` cpp
+explicit wstring_convert(Codecvt* pcvt = new Codecvt);
 wstring_convert(Codecvt* pcvt, state_type state);
+explicit wstring_convert(const byte_string& byte_err,
     const wide_string& wide_err = wide_string());
 ```
+*Requires:* For the first and second constructors, `pcvt != nullptr`.
 *Effects:* The first constructor shall store `pcvt` in `cvtptr` and
 default values in `cvtstate`, `byte_err_string`, and `wide_err_string`.
 The second constructor shall store `pcvt` in `cvtptr`, `state` in
 `cvtstate`, and default values in `byte_err_string` and
 `wide_err_string`; moreover the stored state shall be retained between
   class wbuffer_convert
     : public std::basic_streambuf<Elem, Tr> {
   public:
     typedef typename Codecvt::state_type state_type;
+ explicit wbuffer_convert(std::streambuf* bytebuf = 0,
                              Codecvt* pcvt = new Codecvt,
                              state_type state = state_type());
+    ~wbuffer_convert();
+    wbuffer_convert(const wbuffer_convert&) = delete;
+    wbuffer_convert& operator=(const wbuffer_convert&) = delete;
     std::streambuf* rdbuf() const;
     std::streambuf* rdbuf(std::streambuf* bytebuf);
     state_type state() const;
 The class template describes a stream buffer that controls the
 transmission of elements of type `Elem`, whose character traits are
 described by the class `Tr`, to and from a byte stream buffer of type
 `std::streambuf`. Conversion between a sequence of `Elem` values and
+multibyte sequences is performed by an object of class `Codecvt`, which
+shall meet the requirements of the standard code-conversion facet
 `std::codecvt<Elem, char, std::mbstate_t>`.
 An object of this class template stores:
 - `bufptr` — a pointer to its underlying byte stream buffer
 ```
 The type shall be a synonym for `Codecvt::state_type`.
 ``` cpp
+explicit wbuffer_convert(std::streambuf* bytebuf = 0,
     Codecvt* pcvt = new Codecvt, state_type state = state_type());
 ```
+*Requires:* `pcvt != nullptr`.
 *Effects:* The constructor constructs a stream buffer object,
 initializes `bufptr` to `bytebuf`, initializes `cvtptr` to `pcvt`, and
 initializes `cvtstate` to `state`.
 ``` cpp
 The specializations required in Table
 [[tab:localization.category.facets]] ([[locale.category]]) convert the
 implementation-defined native character set.
 `codecvt<char, char, mbstate_t>` implements a degenerate conversion; it
 does not convert at all. The specialization `codecvt<char16_t,`
+`char, mbstate_t>` converts between the UTF-16 and UTF-8 encoding forms,
+and the specialization `codecvt` `<char32_t, char, mbstate_t>` converts
+between the UTF-32 and UTF-8 encoding forms.
 `codecvt<wchar_t,char,mbstate_t>` converts between the native character
 sets for narrow and wide characters. Specializations on `mbstate_t`
 perform conversion between encodings known to the library implementer.
 Other encodings can be converted by specializing on a user-defined
+`stateT` type. Objects of type `stateT` can contain any state that is
+useful to communicate to or from the specialized `do_in` or `do_out`
+members.
 ##### `codecvt` members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
 result out(stateT& state,
 `do_put(out, str, fill,`
 `(int)val)`, otherwise obtains a string `s` as if by
 ``` cpp
 string_type s =
+  val ? use_facet<numpunct<charT>>(loc).truename()
+    : use_facet<numpunct<charT>>(loc).falsename();
 ```
 and then inserts each character `c` of `s` into `out` via `*out++ = c`
 and returns `out`.
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, ios_base& f,
     ios_base::iostate& err, tm* t, char format, char modifier) const;
 ```
+*Requires:* `t` shall point to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
 or until it has extracted and assigned those `struct tm` members, and
 any remaining format characters, corresponding to a conversion directive
 ``` cpp
 namespace std {
   class messages_base {
   public:
+    typedef unspecified signed integer type catalog;
   };
   template <class charT>
   class messages : public locale::facet, public messages_base {
   public:
   template<class Elem, unsigned long Maxcode = 0x10ffff,
     codecvt_mode Mode = (codecvt_mode)0>
   class codecvt_utf8
     : public codecvt<Elem, char, mbstate_t> {
+  public:
+    explicit codecvt_utf8(size_t refs = 0);
+    ~codecvt_utf8();
   };
   template<class Elem, unsigned long Maxcode = 0x10ffff,
     codecvt_mode Mode = (codecvt_mode)0>
   class codecvt_utf16
     : public codecvt<Elem, char, mbstate_t> {
+  public:
+    explicit codecvt_utf16(size_t refs = 0);
+    ~codecvt_utf16();
   };
   template<class Elem, unsigned long Maxcode = 0x10ffff,
     codecvt_mode Mode = (codecvt_mode)0>
   class codecvt_utf8_utf16
     : public codecvt<Elem, char, mbstate_t> {
+  public:
+    explicit codecvt_utf8_utf16(size_t refs = 0);
+    ~codecvt_utf8_utf16();
   };
 }
 ```
 For each of the three code conversion facets `codecvt_utf8`,

Diff to HTML by rtfpessoa