Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r51845 - sandbox/committee/LWG/cd_status
From: bdawes_at_[hidden]
Date: 2009-03-18 17:12:51

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r51846 - sandbox/committee/LWG/cd_status"
Previous message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r51844 - sandbox/committee/LWG/cd_status"

Author: bemandawes
Date: 2009-03-18 17:12:49 EDT (Wed, 18 Mar 2009)
New Revision: 51845
URL: http://svn.boost.org/trac/boost/changeset/51845

Log:
Restore UK 98 to original position, get rid of many double newlines
Text files modified:
sandbox/committee/LWG/cd_status/comments.xml | 2150 +++++++++++++++++++--------------------
1 files changed, 1074 insertions(+), 1076 deletions(-)

Modified: sandbox/committee/LWG/cd_status/comments.xml
==============================================================================
--- sandbox/committee/LWG/cd_status/comments.xml (original)
+++ sandbox/committee/LWG/cd_status/comments.xml 2009-03-18 17:12:49 EDT (Wed, 18 Mar 2009)
@@ -5,6 +5,29 @@
 docno="PL22.16 09/xxxx = WG21 Nyyyy"
>

+<comment nb="UK" num="98" uknum="402" type="Te" owner="LWG" issue="1055" disp="" date="" extdoc="">
+<section>
+20.5.6
+</section>
+<para></para>
+<description>
+ It would be
+ useful to be able to determine the underlying type of an
+ arbitrary enumeration type. This would allow safe casting
+ to an integral type (especially needed for scoped enums,
+ which do not promote), and would allow use of
+ numeric_limits. In general it makes generic programming
+ with enumerations easier.
+</description>
+<suggestion>
+ Add a TransformationTrait to 20.5.6 that
+ returns the underlying type of an enumeration type.
+</suggestion>
+<notes>Originlly submitted as section: 7.2 Â¶ 5</notes>
+<rationale>
+</rationale>
+</comment>
+
<comment nb="FR" num="1" uknum="" type="ge" owner="" issue="" disp="" date="" extdoc="">
<section>
General Comment
@@ -6622,10 +6645,7 @@
</comment>

<comment nb="JP" num="21" uknum="" type="te" owner="LWG" issue="" disp="rejected" date="" extdoc="">
-<section>
- 17
- Library
- 21.2, 21.4,
+<section>21.2, 21.4,
 27.2, 27.6,
27.7,
27.8.1,
@@ -6645,568 +6665,569 @@
<suggestion>
 Add commented
 lines corresponding to char16_t, char32_t.
- 
+ 

- 
+ 
 21.2 paragraph1
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 ...
- 
+ 

- 
+ 
 // 21.4: numeric conversions
- 
+ 
 ...
- 
+ 

- 
+ 
 int stoi(const u16string& str, size_t *idx = 0,
 int base = 10);
- 
+ 
 long stol(const u16string& str, size_t *idx = 0,
 int base = 10);
- 
+ 
 unsigned long stoul(const u16string& str, size_t
 *idx = 0, int base = 10);
- 
+ 
 long long stoll(const u16string& str, size_t *idx
 = 0, int base = 10);
- 
+ 
 unsigned long long stoull(const u16string& str,
 size_t *idx = 0, int base = 10);
- 
+ 
 float stof(const u16string& str, size_t *idx =
 0);
- 
+ 
 double stod(const u16string& str, size_t *idx =
 0);
- 
+ 
 long double stold(const u16string& str, size_t
 *idx = 0);
- 
+ 
 u16string to_u16string(long long val);
- 
+ 
 u16string to_u16string(unsigned long long val);
- 
+ 
 u16string to_u16string(long double val);
- 
+ 

- 
+ 
 int stoi(const u32string& str, size_t *idx = 0,
 int base = 10);
- 
+ 
 long stol(const u32string& str, size_t *idx = 0,
 int base = 10);
- 
+ 
 unsigned long stoul(const u32string& str, size_t
 *idx = 0, int base = 10);
- 
+ 
 long long stoll(const u32string& str, size_t *idx
 = 0, int base = 10);
- 
+ 
 unsigned long long stoull(const u32string& str,
 size_t *idx = 0, int base = 10);
- 
+ 
 float stof(const u32string& str, size_t *idx =
 0);
- 
+ 
 double stod(const u32string& str, size_t *idx =
 0);
- 
+ 
 long double stold(const u32string& str, size_t
 *idx = 0);
- 
+ 
 u32string to_u32string(long long val);
- 
+ 
 u32string to_u32string(unsigned long long val);
- 
+ 
 u32string to_u32string(long double val);
- }
- 
+ }
+ 

- 
+ 
 27.2
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 ...
- 
+ 
 typedef basic_ios<char> ios;
- 
+ 
 typedef basic_ios<wchar_t> wios;
- 
+ 
 typedef basic_ios<char16_t> u16ios;
- 
+ 
 typedef basic_ios<char32_t> u32ios;
- 
+ 

- 
+ 
 ...
- 
+ 
 typedef basic_ifstream<wchar_t> wifstream;
- 
+ 
 typedef basic_ofstream<wchar_t> wofstream;
- 
+ 
 typedef basic_fstream<wchar_t> wfstream;
- 
+ 

- 
+ 
 typedef basic_streambuf<char16_t> u16streambuf;
- 
+ 
 typedef basic_istream<char16_t> u16istream;
- 
+ 
 typedef basic_ostream<char16_t> u16ostream;
- 
+ 
 typedef basic_iostream<char16_t> u16iostream;
- 
+ 

- 
+ 
 typedef basic_stringbuf<char16_t> u16stringbuf;
- 
+ 
 typedef basic_istringstream<char16_t>
 u16istringstream;
- 
+ 
 typedef basic_ostringstream<char16_t>
 u16ostringstream;
- 
+ 
 typedef basic_stringstream<char16_t>
 u16stringstream;
- 
+ 
 typedef basic_filebuf<char16_t> u16filebuf;
- 
+ 

- 
+ 
 typedef basic_ifstream<char16_t> u16ifstream;
- 
+ 
 typedef basic_ofstream<char16_t> u16ofstream;
- 
+ 
 typedef basic_fstream<char16_t> u16fstream;
- 
+ 

- 
+ 
 typedef basic_streambuf<char32_t> u32streambuf;
- 
+ 
 typedef basic_istream<char32_t> u32istream;
- 
+ 
 typedef basic_ostream<char32_t> u32ostream;
- 
+ 
 typedef basic_iostream<char32_t> u32iostream;
- 
+ 

- 
+ 
 typedef basic_stringbuf<char32_t> u32stringbuf;
- 
+ 
 typedef basic_istringstream<char32_t>
 u32istringstream;
- 
+ 
 typedef basic_ostringstream<char32_t>
 u32ostringstream;
- 
+ 
 typedef basic_stringstream<char32_t>
 u32stringstream;
- 
+ 
 typedef basic_filebuf<char32_t> u32filebuf;
- 
+ 

- 
+ 
 typedef basic_ifstream<char32_t> u32ifstream;
- 
+ 
 typedef basic_ofstream<char32_t> u32ofstream;
- 
+ 
 typedef basic_fstream<char32_t>
 u32fstream;
- 
+ 

- 
+ 
 ...
- 
+ 
 template <class state> class fpos;
- 
+ 
 typedef
 fpos<char_traits<char>::state_type> streampos;
- 
+ 
 typedef
 fpos<char_traits<wchar_t>::state_type>
 wstreampos;
- 
+ 
 typedef
 fpos<char_traits<char16_t>::state_type>
 u16streampos;
- 
+ 
 typedef
 fpos<char_traits<char32_t>::state_type>
 u32streampos;
- }
- 
+ }
+ 

- 
+ 
 27.6
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_istream;
- 
+ 
 typedef basic_istream<char> istream;
- 
+ 
 typedef basic_istream<wchar_t> wistream;
- 
+ 
 typedef basic_istream<char16_t>
 u16istream;
- 
+ 
 typedef basic_istream<char32_t> u32istream;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_iostream;
- 
+ 
 typedef basic_iostream<char> iostream;
- 
+ 
 typedef basic_iostream<wchar_t> wiostream;
- 
+ 
 typedef basic_iostream<char16_t>
 u16iostream;
- 
+ 
 typedef basic_iostream<char32_t> u32iostream;
- }
- 
+ }
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_ostream;
- 
+ 
 typedef basic_ostream<char> ostream;
- 
+ 
 typedef basic_ostream<wchar_t> wostream;
- 
+ 
 typedef basic_ostream<char16_t>
 u16ostream;
- 
+ 
 typedef basic_ostream<char32_t> u32ostream;
- }
- 
+ }
+ 

- 
+ 
 27.7 paragraph 1
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 class Allocator =
 allocator<charT> >
- 
+ 
 class basic_stringbuf;
- 
+ 

- 
+ 
 typedef basic_stringbuf<char> stringbuf;
- 
+ 
 typedef basic_stringbuf<wchar_t> wstringbuf;
- 
+ 
 typedef basic_stringbuf<char16_t>
 u16stringbuf;
- 
+ 
 typedef basic_stringbuf<char32_t> u32stringbuf;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 class Allocator =
 allocator<charT> >
- 
+ 
 class basic_istringstream;
- 
+ 

- 
+ 
 typedef basic_istringstream<char>
 istringstream;
- 
+ 
 typedef basic_istringstream<wchar_t>
 wistringstream;
- 
+ 
 typedef basic_istringstream<char16_t>
 u16istringstream;
- 
+ 
 typedef basic_istringstream<char32_t>
 u32istringstream;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 class Allocator =
 allocator<charT> >
- 
+ 
 class basic_ostringstream;
- 
+ 

- 
+ 
 typedef basic_ostringstream<char>
 ostringstream;
- 
+ 
 typedef basic_ostringstream<wchar_t>
 wostringstream;
- 
+ 
 typedef basic_ostringstream<char16_t>
 u16ostringstream;
- 
+ 
 typedef basic_ostringstream<char32_t>
 u32ostringstream;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 class Allocator =
 allocator<charT> >
- 
+ 
 class basic_stringstream;
- 
+ 

- 
+ 
 typedef basic_stringstream<char> stringstream;
- 
+ 
 typedef basic_stringstream<wchar_t>
 wstringstream;
- 
+ 
 typedef basic_stringstream<char16_t>
 u16stringstream;
- 
+ 
 typedef basic_stringstream<char32_t>
 u32stringstream;
- }
- 
+ }
+ 

- 
+ 
 27.8.1 paragraph 1
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_filebuf;
- 
+ 
 typedef basic_filebuf<char> filebuf;
- 
+ 
 typedef basic_filebuf<wchar_t> wfilebuf;
- 
+ 
 typedef basic_filebuf<char16_t>
 u16filebuf;
- 
+ 
 typedef basic_filebuf<char32_t> u32filebuf;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_ifstream;
- 
+ 
 typedef basic_ifstream<char> ifstream;
- 
+ 
 typedef basic_ifstream<wchar_t> wifstream;
- 
+ 
 typedef basic_ifstream<char16_t>
 u16ifstream;
- 
+ 
 typedef basic_ifstream<char32_t> u32ifstream;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_ofstream;
- 
+ 
 typedef basic_ofstream<char> ofstream;
- 
+ 
 typedef basic_ofstream<wchar_t> wofstream;
- 
+ 
 typedef basic_ofstream<char16_t>
 u16ofstream;
- 
+ 
 typedef basic_ofstream<char32_t> u32ofstream;
- 
+ 

- 
+ 
 template <class charT, class traits =
 char_traits<charT> >
- 
+ 
 class basic_fstream;
- 
+ 
 typedef basic_fstream<char> fstream;
- 
+ 
 typedef basic_fstream<wchar_t> wfstream;
- 
+ 
 typedef basic_fstream<char16_t>
 u16fstream;
- 
+ 
 typedef basic_fstream<char32_t> u32fstream;
- }
- 
+ }
+ 

- 
+ 
 28.4
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 ...
- 
+ 
 typedef basic_regex<char> regex;
- 
+ 
 typedef basic_regex<wchar_t> wregex;
- 
+ 
 typedef basic_regex<char16_t> u16regex;
- 
+ 
 typedef basic_regex<char32_t> u32regex;
- 
+ 

- 
+ 
 ...
- 
+ 
 typedef sub_match<const char*> csub_match;
- 
+ 
 typedef sub_match<const wchar_t*> wcsub_match;
- 
+ 
 typedef sub_match<const char16_t*>
 u16csub_match;
- 
+ 
 typedef sub_match<const char32_t*>
 u16csub_match;
- 
+ 
 typedef sub_match<string::const_iterator>
 ssub_match;
- 
+ 
 typedef sub_match<wstring::const_iterator>
 wssub_match;
- 
+ 
 typedef sub_match<u16string::const_iterator>
 u16ssub_match;
- 
+ 
 typedef sub_match<u32string::const_iterator>
 u32ssub_match;
- 
+ 

- 
+ 
 ...
- 
+ 
 typedef match_results<const char*> cmatch;
- 
+ 
 typedef match_results<const wchar_t*> wcmatch;
- 
+ 
 typedef match_results<const char16_t*>
 u16cmatch;
- 
+ 
 typedef match_results<const char32_t*>
 u32cmatch;
- 
+ 
 typedef match_results<string::const_iterator>
 smatch;
- 
+ 
 typedef match_results<wstring::const_iterator>
 wsmatch;
- 
+ 
 typedef
 match_results<u16string::const_iterator> u16smatch;
- 
+ 
 typedef
 match_results<u32string::const_iterator> u32smatch;
- 
+ 

- 
+ 
 ...
- 
+ 
 typedef regex_iterator<const char*>
 cregex_iterator;
- 
+ 
 typedef regex_iterator<const wchar_t*>
 wcregex_iterator;
- 
+ 
 typedef regex_iterator<const cha16r_t*>
 u16cregex_iterator;
- 
+ 
 typedef regex_iterator<const char32_t*>
 u32cregex_iterator;
- 
+ 
 typedef regex_iterator<string::const_iterator>
 sregex_iterator;
- 
+ 
 typedef regex_iterator<wstring::const_iterator>
 wsregex_iterator;
- 
+ 
 typedef
 regex_iterator<u16string::const_iterator>
 u16sregex_iterator;
- 
+ 
 typedef
 regex_iterator<u32string::const_iterator>
 u32sregex_iterator;
- 
+ 

- 
+ 
 ...
- 
+ 
 typedef regex_token_iterator<const char*>
 cregex_token_iterator;
- 
+ 
 typedef regex_token_iterator<const wchar_t*>
 wcregex_token_iterator;
- 
+ 
 typedef regex_token_iterator<const char16_t*>
 u16cregex_token_iterator;
- 
+ 
 typedef regex_token_iterator<const char32_t*>
 u32cregex_token_iterator;
- 
+ 
 typedef
 regex_token_iterator<string::const_iterator>
 sregex_token_iterator;
- 
+ 
 typedef
 regex_token_iterator<wstring::const_iterator>
 　　　wsregex_token_iterator;
- 
+ 
 typedef
 regex_token_iterator<u16string::const_iterator>
 u16sregex_token_iterator;
- 
+ 
 typedef
 regex_token_iterator<u32string::const_iterator>
 　u32sregex_token_iterator;
- }
+ }
</suggestion>
<notes>
-Done
+Done. Original section of "17 Library" deleted so that comment will sort as the first actual
+section affected.
</notes>
<rationale>
Previously considered; we decided not to do it. We believe it is
@@ -8286,30 +8307,30 @@
</description>
<suggestion>
 Correct as follows.
- 
+ 

- 
+ 
 template<class T> class numeric_limits<const
 T>;
- 
+ 
 template<class T> class numeric_limits<volatile
 T>;
- 
+ 
 template<class T> class numeric_limits<const
 volatile T>;
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 template<Regular T> class
 numeric_limits<const T>;
- 
+ 
 template<Regular T> class
 numeric_limits<volatile T>;
- 
+ 
 template<Regular T> class
 numeric_limits<const volatile T>;
</suggestion>
@@ -9243,32 +9264,9 @@
</rationale>
</comment>

-<comment nb="UK" num="98" uknum="402" type="Te" owner="LWG" issue="1055" disp="" date="" extdoc="">
+<comment nb="UK" num="204" uknum="239" type="Te" owner="LWG" issue="1020" disp="accepted" date="" extdoc="">
<section>
-20.5.6
-</section>
-<para></para>
-<description>
- It would be
- useful to be able to determine the underlying type of an
- arbitrary enumeration type. This would allow safe casting
- to an integral type (especially needed for scoped enums,
- which do not promote), and would allow use of
- numeric_limits. In general it makes generic programming
- with enumerations easier.
-</description>
-<suggestion>
- Add a TransformationTrait to 20.5.6 that
- returns the underlying type of an enumeration type.
-</suggestion>
-<notes>Originlly submitted as section: 7.2 Â¶ 5</notes>
-<rationale>
-</rationale>
-</comment>
-
-<comment nb="UK" num="204" uknum="239" type="Te" owner="LWG" issue="1020" disp="accepted" date="" extdoc="">
-<section>
-20.5.7 [meta.trans.other]
+20.5.7 [meta.trans.other]
</section>
<para>
Table 41
@@ -9557,33 +9555,33 @@
 
 template<class F, Allocator A>
 function(allocator_arg_t, const A&, F);
- 
+ 
 template<class F, Allocator A>
 function(allocator_arg_t, const A&, F&&);
- 
+ 

- should be
- 
+ should be
+ 

- 
+ 
 template<class F, Allocator A>
- 
+ 
 requires CopyConstructible<F> &&
 Callable<F, ArgTypes...>
- 
+ 
 && Convertible<Callable<F,
 ArgTypes...>::result_type, R>
- 
+ 
 function(allocator_arg_t, const A&, F);
- 
+ 
 template<class F, Allocator A>
- 
+ 
 requires CopyConstructible<F> &&
 Callable<F, ArgTypes...>
- 
+ 
 && Convertible<Callable<F,
 ArgTypes...>::result_type, R>
- 
+ 
 function(allocator_arg_t, const A&, F&&);
</suggestion>
<notes>
@@ -9669,26 +9667,26 @@
 Correct as follows.
 
 template <class R, class... Args>
- 
+ 
 concept_map UsesAllocator<function<R(Args...)>,
 Alloc> {
- 
+ 
 typedef Alloc allocator_type;
- }
- 
+ }
+ 

- should be
- 
+ should be
+ 

- 
+ 
 template <Returnable R,
 CopyConstructible... Args>
- 
+ 
 concept_map UsesAllocator<function<R(Args...)>,
 Alloc> {
- 
+ 
 typedef Alloc allocator_type;
- }
+ }
</suggestion>
<notes>Done</notes>
<rationale>This change would be redundant because function<> is already sufficiently
@@ -9712,71 +9710,71 @@
</description>
<suggestion>
 Correct as follows.
- 
+ 

- 
+ 
 template <MoveConstructible R, MoveConstructible...
 ArgTypes>
- 
+ 
 bool operator==(const function<R(ArgTypes...)>&,
 nullptr_t);
- 
+ 
 template <MoveConstructible R, MoveConstructible...
 ArgTypes>
- 
+ 
 bool operator==(nullptr_t, const
 function<R(ArgTypes...)>&);
- 
+ 
 template <MoveConstructible R, MoveConstructible...
 ArgTypes>
- 
+ 
 bool operator!=(const function<R(ArgTypes...)>&,
 nullptr_t);
- 
+ 
 template <MoveConstructible R, MoveConstructible...
 ArgTypes>
- 
+ 
 bool operator!=(nullptr_t, const
 function<R(ArgTypes...)>&);
- 
+ 
 template <MoveConstructible R, MoveConstructible...
 ArgTypes>
- 
+ 
 void swap(function<R(ArgTypes...)>&,
 function<R(ArgTypes...)>&);
- 
+ 

- should be
- 
+ should be
+ 

- 
+ 
 template <Returnable R,
 CopyConstructible... ArgTypes>
- 
+ 
 bool operator==(const function<R(ArgTypes...)>&,
 nullptr_t);
- 
+ 
 template <Returnable R,
 CopyConstructible... ArgTypes>
- 
+ 
 bool operator==(nullptr_t, const
 function<R(ArgTypes...)>&);
- 
+ 
 template <Returnable R,
 CopyConstructible... ArgTypes>
- 
+ 
 bool operator!=(const function<R(ArgTypes...)>&,
 nullptr_t);
- 
+ 
 template <Returnable R,
 CopyConstructible... ArgTypes>
- 
+ 
 bool operator!=(nullptr_t, const
 function<R(ArgTypes...)>&);
- 
+ 
 template <Returnable R,
 CopyConstructible... ArgTypes>
- void
+ void
 swap(function<R(ArgTypes...)>&,
 function<R(ArgTypes...)>&);
</suggestion>
@@ -10465,61 +10463,61 @@
 requiring the client to extract and operate directly on the
 duration’s representation as the latter will not
 enforce the correct units of the operation.
- 
+ 

- Ex:
- 
+ Ex:
+ 

- 
+ 
 milliseconds ms(...);
- 
+ 
 microseconds us(...);
- 
+ 

- ms
+ ms
 % us; // microseconds
- us
+ us
 % ms; // microseconds
- ms
+ ms
 % 5; // milliseconds
- 5 %
+ 5 %
 ms; // does not compile
</description>
<suggestion>
 Add:
- 
- 
+ 
+ 
 template <class Rep, class Period = ratio<1>>
- 
+ 
 class duration {
- 
+ 
 public:
- ...
- duration&
+ ...
+ duration&
 operator%(const rep&);
- duration&
+ duration&
 operator%(const duration&);
- ..
- };
- 
- template
+ ..
+ };
+ 
+ template
 <class Rep1, class Period,
- class Rep2>
- 
+ class Rep2>
+ 
 duration<typename common_type<
- Rep1,
+ Rep1,
 Rep2>::type, Period>
- operator%(const
+ operator%(const
 duration<Rep1, Period>& d, const Rep2& s);
- 
- template
+ 
+ template
 <class Rep1, class Period1,
- class Rep2,
+ class Rep2,
 class Period2>
- typename
+ typename
 common_type<duration<Rep1, Period1>,
 duration<Rep2, Period2>>::type
- operator%(const
+ operator%(const
 duration<Rep1, Period1>& lhs, const
 duration<Rep2, Period2>& rhs);
</suggestion>
@@ -10591,693 +10589,693 @@
 "class InputIterator" is changed to "InputIterator Iter".
 

- //
+ //
 21.3, basic_string:
- 
+ 
 template<class charT, class traits =
 char_traits<charT>,
- 
+ 
 Allocator Alloc = allocator<charT> >
- 
+ 
 class basic_string;
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>
- 
+ 
 operator+(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(basic_string<charT,traits,Alloc>&&
 lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 basic_string<charT,traits,Alloc>&&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(basic_string<charT,traits,Alloc>&&
 lhs,
- 
+ 
 basic_string<charT,traits,Alloc>&&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>
- 
+ 
 operator+(const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(const charT* lhs,
- 
+ 
 basic_string<charT,traits,Alloc>&&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>
- 
+ 
 operator+(charT lhs, const
 basic_string<charT,traits,Alloc>& rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(charT lhs,
 basic_string<charT,traits,Alloc>&&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>
- 
+ 
 operator+(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(basic_string<charT,traits,Alloc>&&
 lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>
- 
+ 
 operator+(const
 basic_string<charT,traits,Alloc>& lhs,
 charT rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_string<charT,traits,Alloc>&&
- 
+ 
 operator+(basic_string<charT,traits,Alloc>&&
 lhs, charT rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator==(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator==(const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator==(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator!=(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator!=(const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator!=(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator< (const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator< (const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator< (const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator> (const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator> (const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator> (const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator<=(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator<=(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator<=(const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator>=(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator>=(const
 basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 const charT* rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 bool operator>=(const charT* lhs,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 rhs);
- 
+ 

- //
+ //
 21.3.8.8: swap
- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 basic_string<charT,traits,Alloc>& rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_string<charT,traits,Alloc>&&
 lhs,
- 
+ 
 basic_string<charT,traits,Alloc>& rhs);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_string<charT,traits,Alloc>& lhs,
- 
+ 
 basic_string<charT,traits,Alloc>&& rhs);
- 
+ 

- //
+ //
 21.3.8.9: inserters and extractors
- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_istream<charT,traits>&
- 
+ 
 operator>>(basic_istream<charT,traits>&&
 is,
- 
+ 
 basic_string<charT,traits,Alloc>& str);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_ostream<charT, traits>&
- 
+ 
 operator<<(basic_ostream<charT,
 traits>&& os,
- 
+ 
 const basic_string<charT,traits,Alloc>&
 str);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_istream<charT,traits>&
- 
+ 
 getline(basic_istream<charT,traits>&& is,
- 
+ 
 basic_string<charT,traits,Alloc>& str,
- 
+ 
 charT delim);
- 
+ 

- 
+ 
 template<class charT, class traits, Allocator
 Alloc>
- 
+ 
 basic_istream<charT,traits>&
- 
+ 
 getline(basic_istream<charT,traits>&& is,
- 
+ 
 basic_string<charT,traits,Alloc>& str);
- 
+ 

- 
+ 

- //
+ //
 21.3 Class template basic_string
- 
+ 
 namespace std {
- 
+ 
 template<class charT, class traits =
 char_traits<charT>,
- 
+ 
 Allocator Alloc = allocator<charT> >
- 
+ 
 class basic_string {
- 
+ 
 public:
- //
+ //
 types:
- 
+ 
 typedef traits traits_type;
- 
+ 
 typedef typename traits::char_type value_type;
- 
+ 
 typedef Alloc allocator_type;
- 
+ 
 typedef typename Alloc::size_type size_type;
- 
+ 
 typedef typename Alloc::difference_type
 difference_type;
- 
+ 
 typedef typename Alloc::reference reference;
- 
+ 
 typedef typename Alloc::const_reference
 const_reference;
- 
+ 
 typedef typename Alloc::pointer pointer;
- 
+ 
 typedef typename Alloc::const_pointer const_pointer;
- 
+ 
 typedef implementation-defined iterator; // See 23.1
- 
+ 
 typedef implementation-defined const_iterator; // See 23.1
- 
+ 
 typedef std::reverse_iterator<iterator>
 reverse_iterator;
- 
+ 
 typedef std::reverse_iterator<const_iterator>
 const_reverse_iterator;
- 
+ 
 static const size_type npos = -1;
- 
+ 

- //
+ //
 21.3.2 construct/copy/destroy:
- 
+ 
 explicit basic_string(const Alloc& a =
 Alloc());
- 
+ 
 basic_string(const basic_string& str);
- 
+ 
 basic_string(basic_string&& str);
- 
+ 
 basic_string(const basic_string& str, size_type pos,
 size_type n = npos,
- 
+ 
 const Alloc& a = Alloc());
- 
+ 
 basic_string(const charT* s,
- 
+ 
 size_type n, const Alloc& a = Alloc());
- 
+ 
 basic_string(const charT* s, const Alloc& a =
 Alloc());
- 
+ 
 basic_string(size_type n, charT c, const Alloc&
 a = Alloc());
- 
+ 
 template<InputIterator Iter>
- 
+ 
 basic_string(Iter begin, Iter end,
- 
+ 
 const Alloc& a = Alloc());
- 
+ 
 basic_string(initializer_list<charT>, const
 Alloc& = Alloc());
- 
+ 
 basic_string(const basic_string&, const
 Alloc&);
- 
+ 
 basic_string(basic_string&&, const
 Alloc&);
- 
+ 
 ~basic_string();
- 
+ 
 basic_string& operator=(const basic_string& str);
- 
+ 
 basic_string& operator=(basic_string&& str);
- 
+ 
 basic_string& operator=(const charT* s);
- 
+ 
 basic_string& operator=(charT c);
- 
+ 
 basic_string& operator=(initializer_list<charT>);
- 
+ 

- //
+ //
 21.3.3 iterators:
- ...
- 
+ ...
+ 

- //
+ //
 21.3.4 capacity:
- ...
- 
+ ...
+ 

- //
+ //
 21.3.5 element access:
- ...
- 
+ ...
+ 

- //
+ //
 21.3.6 modifiers:
- ...
- 
+ ...
+ 

- 
+ 
 basic_string& append(const basic_string& str);
- 
+ 
 basic_string& append(const basic_string& str,
 size_type pos,
- 
+ 
 size_type n);
- 
+ 
 basic_string& append(const charT* s, size_type n);
- 
+ 
 basic_string& append(const charT* s);
- 
+ 
 basic_string& append(size_type n, charT c);
- 
+ 
 template<InputIterator Iter>
- 
+ 
 basic_string& append(Iter first, Iter
 last);
- 
+ 
 basic_string& append(initializer_list<charT>);
- 
+ 
 void push_back(charT c);
- 
+ 

- 
+ 
 basic_string& assign(const basic_string& str);
- 
+ 
 basic_string& assign(basic_string&& str);
- 
+ 
 basic_string& assign(const basic_string& str,
 size_type pos,
- 
+ 
 size_type n);
- 
+ 
 basic_string& assign(const charT* s, size_type n);
- 
+ 
 basic_string& assign(const charT* s);
- 
+ 
 basic_string& assign(size_type n, charT c);
- 
+ 
 template<InputIterator Iter>
- 
+ 
 basic_string& assign(Iter first, Iter
 last);
- 
+ 
 basic_string& assign(initializer_list<charT>);
- 
+ 

- 
+ 
 basic_string& insert(size_type pos1, const
 basic_string& str);
- 
+ 
 basic_string& insert(size_type pos1, const
 basic_string& str,
- 
+ 
 size_type pos2, size_type n);
- 
+ 
 basic_string& insert(size_type pos, const charT* s,
 size_type n);
- 
+ 
 basic_string& insert(size_type pos, const charT* s);
- 
+ 
 basic_string& insert(size_type pos, size_type n, charT
 c);
- 
+ 
 iterator insert(const_iterator p, charT c);
- 
+ 
 void insert(const_iterator p, size_type n, charT c);
- 
+ 
 template<InputIterator Iter>
- 
+ 
 void insert(const_iterator p, Iter first,
 Iter last);
- 
+ 
 void insert(const_iterator p,
 initializer_list<charT>);
- 
+ 

- ...
- 
+ ...
+ 
 basic_string& replace(size_type pos1, size_type n1,
- 
+ 
 const basic_string& str);
- 
+ 
 basic_string& replace(size_type pos1, size_type n1,
- 
+ 
 const basic_string& str,
- 
+ 
 size_type pos2, size_type n2);
- 
+ 
 basic_string& replace(size_type pos, size_type n1,
 const charT* s,
- 
+ 
 size_type n2);
- 
+ 
 basic_string& replace(size_type pos, size_type n1,
 const charT* s);
- 
+ 
 basic_string& replace(size_type pos, size_type n1,
 size_type n2,
- 
+ 
 charT c);
- 
+ 
 basic_string& replace(iterator i1, iterator i2,
- 
+ 
 const basic_string& str);
- 
+ 
 basic_string& replace(iterator i1, iterator i2, const
 charT* s,
- 
+ 
 size_type n);
- 
+ 
 basic_string& replace(iterator i1, iterator i2, const
 charT* s);
- 
+ 
 basic_string& replace(iterator i1, iterator i2,
- 
+ 
 size_type n, charT c);
- 
+ 
 template<InputIterator Iter>
- 
+ 
 basic_string& replace(iterator i1, iterator i2,
- 
+ 
 Iter j1, Iter j2);
- 
+ 
 basic_string& replace(iterator, iterator,
 initializer_list<charT>);
- 
+ 

- ...
- 
+ ...
+ 

- //
+ //
 21.3.7 string operations:
- ...
- 
+ ...
+ 

- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 struct constructible_with_allocator_suffix<
- 
+ 
 basic_string<charT, traits, Alloc> > :
 true_type { };
</suggestion>
@@ -11497,35 +11495,35 @@
</description>
<suggestion>
 Correct as follows.
- 
+ 
 template<class Codecvt, class Elem = wchar_t> class
 wstring_convert {
- 
+ 
 public:
- 
+ 
 typedef std::basic_string<char> byte_string;
- 
+ 
 typedef std::basic_string<Elem> wide_string;
- 
+ 

- should be
- 
+ should be
+ 

- 
+ 
 template<class Codecvt, class Elem = wchar_t,
- 
+ 
 Allocator WideAllocator = allocator<Elem>,
- 
+ 
 Allocator ByteAllocator = allocator<char>>
- 
+ 
 class wstring_convert {
- 
+ 
 public:
- 
+ 
 typedef std::basic_string<char,
 char_traits<char>, ByteAllocator>
 byte_string;
- typedef
+ typedef
 std::basic_string<Elem, char_traits<Elem>,
 WideAllocator> wide_string;
</suggestion>
@@ -11674,13 +11672,13 @@
 Correct as follows.
 
 Requires: [fmt,end) shall be a valid range.
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 Requires: [fmt,fmtend) shall be a valid range.
</suggestion>
<notes>[Being reviewed by Editor]</notes>
@@ -11701,116 +11699,116 @@
</description>
<suggestion>
 Correct as follows.
- 
+ 

- 
+ 
 22.2.5.1
- 
+ 

- 
+ 
 template <class charT, class InputIterator =
 istreambuf_iterator<charT> >
- 
+ 
 class time_get : public locale::facet, public time_base {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef InputIterator iter_type;
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 template <class charT, InputIterator InputIter =
 istreambuf_iterator<charT> >
- 
+ 
 class time_get : public locale::facet, public time_base {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef InputIter iter_type;
- 
+ 

- 
+ 

- 
+ 
 22.2.5.2
- 
+ 

- 
+ 
 template <class charT, class InputIterator =
 istreambuf_iterator<charT> >
- 
+ 
 class time_get_byname : public time_get<charT,
 InputIterator> {
- 
+ 
 public:
- 
+ 
 typedef time_base::dateorder dateorder;
- 
+ 
 typedef InputIterator iter_type;
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 template <class charT, InputIterator InputIter =
 istreambuf_iterator<charT> >
- 
+ 
 class time_get_byname : public time_get<charT,
 InputIter> {
- 
+ 
 public:
- 
+ 
 typedef time_base::dateorder dateorder;
- 
+ 
 typedef InputIter iter_type;
- 
+ 

- 
+ 

- 
+ 
 22.2.6.1
- 
+ 

- 
+ 
 template <class charT,
- 
+ 
 class InputIterator = istreambuf_iterator<charT> >
- 
+ 
 class money_get : public locale::facet {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef InputIterator iter_type;
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 template <class charT,
- 
+ 
 InputIterator InputIter =
 istreambuf_iterator<charT> >
- 
+ 
 class money_get : public locale::facet {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef InputIter iter_type;
</suggestion>
<notes>to be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger</notes>
@@ -11830,79 +11828,79 @@
</description>
<suggestion>
 Correct as follows.
- 
+ 

- 
+ 
 22.2.5.3
- 
+ 

- 
+ 
 template <class charT, class OutputIterator =
 ostreambuf_iterator<charT> >
- 
+ 
 class time_put : public locale::facet {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef OutputIterator iter_type;
- 
+ 

- 
+ 
 　should be
- 
+ 

- 
+ 
 template <class charT, OutputIterator OutputIter
 = ostreambuf_iterator<charT> >
- 
+ 
 class time_put : public locale::facet {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef OutputIter iter_type;
- 
+ 

- 
+ 

- 
+ 
 22.2.5.4
- 
+ 

- 
+ 
 template <class charT, class OutputIterator =
 ostreambuf_iterator<charT> >
- 
+ 
 class time_put_byname : public time_put<charT,
 OutputIterator>
- {
- 
+ {
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef OutputIterator iter_type;
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 template <class charT, OutputIterator OutputIter
 = ostreambuf_iterator<charT> >
- 
+ 
 class time_put_byname : public time_put<charT,
 OutputIter>
- {
- 
+ {
+ 
 public:
- 
+ 
 typedef charT char_type;
- typedef OutputIter
+ typedef OutputIter
 iter_type;
</suggestion>
<notes>to be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger</notes>
@@ -13291,110 +13289,110 @@
<description>
 Capability of an iterator is too much restricted by
 concept.
- 
+ 

- 
+ 
 Concept of std::Range is defined as:
- 
+ 

- 
+ 
 concept Range<typename T> {
- 
+ 
 InputIterator iterator;
- 
+ 
 iterator begin(T&);
- 
+ 
 iterator end(T&);
- }
- 
+ }
+ 

- So
+ So
 the following code generates an error.
- 
+ 

- 
+ 
 template <std::Range Rng>
- 
+ 
 void sort(Rng& r)
- {
- 
+ {
+ 
 // error! Rng::iterator does not satisfy requirements of a
 random
- 
+ 
 // access iterator.
- 
+ 
 std::sort(begin(r), end(r));
- }
- 
+ }
+ 

- 
+ 
 std::vector<int> v; // vector::iterator is a random
 access iterator.
- 
+ 
 sort(v);
- 
+ 

- 
+ 
 This is because the concept of an iterator of std::Range is
 InputIterator. For this reason, a random access iterator
 loses its capability when passed to a std::Range parameter.
- 
+ 

- To
+ To
 be able to work the above code, we need to write as
 follows:
- 
+ 

- 
+ 
 template <std::Range T>
- 
+ 
 requires std::RandomAccessIterator<T::iterator>
 &&
- 
+ 
 std::ShuffleIterator<T::iterator> &&
- 
+ 
 std::LessThanComparable<T::iterator::value_type>
- 
+ 
 void sort(T& r)
- {
- 
+ {
+ 
 sort(begin(r), end(r));
- }
- 
+ }
+ 

- 
+ 
 std::vector<int> v;
- 
+ 
 sort(v);
- 
+ 

- It
+ It
 needs quiet a few amount of codes like this only to recover
 random access capability from InputIterator concept.
- 
+ 

- We
+ We
 can write the following valid code with Boost.Range, which
 is implemented with using C++03 SFINAE.
- 
+ 

- 
+ 
 template <class Range>
- 
+ 
 void sort(Range& r)
- {
- 
+ {
+ 
 std::sort(boost::begin(r), boost::end(r));
- }
- 
+ }
+ 

- 
+ 
 std::vector<int> v;
- 
+ 
 sort(v); // OK
- 
+ 

- One of the
+ One of the
 motivation to introduce concepts are supporting template
 programming techniques by language directly to eliminate
 hacky techniques such as tag-dispatch, SFINAE and Type
@@ -14680,84 +14678,84 @@
 Alloc”.
 
 Correct as follows.
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 Allocator Alloc = allocator<charT> >
- 
+ 
 class basic_stringbuf : public
 basic_streambuf<charT,traits> {
- 
+ 
 public:
- ...
- 
+ ...
+ 

- //
+ //
 27.7.1.1 Constructors:
- 
+ 
 explicit basic_stringbuf(ios_base::openmode which
- =
+ =
 ios_base::in | ios_base::out);
- 
+ 
 explicit basic_stringbuf
- 
+ 
 (const basic_string<charT,traits,Alloc>&
 str,
- 
+ 
 ios_base::openmode which = ios_base::in | ios_base::out);
- 
+ 
 basic_stringbuf(basic_stringbuf&& rhs);
- 
+ 

- ...
- 
+ ...
+ 

- 
+ 

- //
+ //
 27.7.1.3 Get and set:
- 
+ 
 basic_string<charT,traits,Alloc> str() const;
- 
+ 
 void str(const
 basic_string<charT,traits,Alloc>& s);
- 
+ 

- ...
- };
- 
+ ...
+ };
+ 

- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_stringbuf<charT, traits,
 Alloc>& x,
- 
+ 
 basic_stringbuf<charT, traits, Alloc>& y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_stringbuf<charT, traits,
 Alloc>&& x,
- 
+ 
 basic_stringbuf<charT, traits, Alloc>& y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_stringbuf<charT, traits,
 Alloc>& x,
- 
+ 
 basic_stringbuf<charT, traits,
 Alloc>&& y);
- }
+ }
</suggestion>
<notes>
</notes>
@@ -14779,109 +14777,109 @@
 Alloc”.
 
 Correct as follows.
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 Allocator Alloc = allocator<charT> >
- 
+ 
 class basic_istringstream : public
 basic_istream<charT,traits> {
- 
+ 
 public:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef typename traits::int_type int_type;
- 
+ 
 typedef typename traits::pos_type pos_type;
- 
+ 
 typedef typename traits::off_type off_type;
- 
+ 
 typedef traits traits_type;
- 
+ 
 typedef Alloc allocator_type;
- 
+ 

- //
+ //
 27.7.2.1 Constructors:
- 
+ 
 explicit basic_istringstream(ios_base::openmode which =
 ios_base::in);
- 
+ 
 explicit basic_istringstream(
- 
+ 
 const basic_string<charT,traits,Alloc>&
 str,
- 
+ 
 ios_base::openmode which = ios_base::in);
- 
+ 
 basic_istringstream(basic_istringstream&& rhs);
- 
+ 

- //
+ //
 27.7.2.2 Assign and swap:
- 
+ 
 basic_istringstream&
 operator=(basic_istringstream&& rhs);
- 
+ 
 void swap(basic_istringstream&& rhs);
- 
+ 

- //
+ //
 27.7.2.3 Members:
- 
+ 
 basic_stringbuf<charT,traits,Alloc>* rdbuf()
 const;
- 
+ 

- 
+ 
 basic_string<charT,traits,Alloc> str() const;
- 
+ 
 void str(const
 basic_string<charT,traits,Alloc>& s);
- 
+ 

- 
+ 
 private:
- //
+ //
 basic_stringbuf<charT,traits,Alloc> sb;
 exposition only
- };
- 
+ };
+ 

- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_istringstream<charT, traits,
 Alloc>& x,
- 
+ 
 basic_istringstream<charT, traits, Alloc>&
 y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_istringstream<charT, traits,
 Alloc>&& x,
- 
+ 
 basic_istringstream<charT, traits, Alloc>&
 y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_istringstream<charT, traits,
 Alloc>& x,
- 
+ 
 basic_istringstream<charT, traits,
 Alloc>&& y);
- }
+ }
</suggestion>
<notes>
</notes>
@@ -14903,109 +14901,109 @@
 Alloc”.
 
 Correct as follows.
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 Allocator Alloc = allocator<charT> >
- 
+ 
 class basic_ostringstream : public
 basic_ostream<charT,traits> {
- 
+ 
 public:
- //
+ //
 types:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef typename traits::int_type int_type;
- 
+ 
 typedef typename traits::pos_type pos_type;
- 
+ 
 typedef typename traits::off_type off_type;
- 
+ 
 typedef traits traits_type;
- 
+ 
 typedef Alloc allocator_type;
- 
+ 

- //
+ //
 27.7.3.1 Constructors/destructor:
- 
+ 
 explicit basic_ostringstream(ios_base::openmode which =
 ios_base::out);
- 
+ 
 explicit basic_ostringstream(
- 
+ 
 const basic_string<charT,traits,Alloc>&
 str,
- 
+ 
 ios_base::openmode which = ios_base::out);
- 
+ 
 basic_ostringstream(basic_ostringstream&& rhs);
- 
+ 

- //
+ //
 27.7.3.2 Assign/swap:
- 
+ 
 basic_ostringstream&
 operator=(basic_ostringstream&& rhs);
- 
+ 
 void swap(basic_ostringstream&& rhs);
- 
+ 

- //
+ //
 27.7.3.3 Members:
- 
+ 
 basic_stringbuf<charT,traits,Alloc>* rdbuf()
 const;
- 
+ 
 basic_string<charT,traits,Alloc> str() const;
- 
+ 
 void str(const
 basic_string<charT,traits,Alloc>& s);
- 
+ 
 private:
- //
+ //
 basic_stringbuf<charT,traits,Alloc> sb;
 exposition only
- };
- 
+ };
+ 

- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_ostringstream<charT, traits,
 Alloc>& x,
- 
+ 
 basic_ostringstream<charT, traits, Alloc>&
 y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_ostringstream<charT, traits,
 Alloc>&& x,
- 
+ 
 basic_ostringstream<charT, traits, Alloc>&
 y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_ostringstream<charT, traits,
 Alloc>& x,
- 
+ 
 basic_ostringstream<charT, traits,
 Alloc>&& y);
- }
+ }
</suggestion>
<notes>
</notes>
@@ -15056,107 +15054,107 @@
 Replace "class Allocator" to "Allocator Alloc".
 
 Correct as follows.
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 template <class charT, class traits =
 char_traits<charT>,
- 
+ 
 Allocator Alloc = allocator<charT> >
- 
+ 
 class basic_stringstream
- :
+ :
 public basic_iostream<charT,traits> {
- 
+ 
 public:
- //
+ //
 types:
- 
+ 
 typedef charT char_type;
- 
+ 
 typedef typename traits::int_type int_type;
- 
+ 
 typedef typename traits::pos_type pos_type;
- 
+ 
 typedef typename traits::off_type off_type;
- 
+ 
 typedef traits traits_type;
- 
+ 
 typedef Alloc allocator_type;
- 
+ 

- //
+ //
 constructors/destructor
- 
+ 
 explicit basic_stringstream(
- 
+ 
 ios_base::openmode which = ios_base::out|ios_base::in);
- 
+ 
 explicit basic_stringstream(
- 
+ 
 const basic_string<charT,traits,Alloc>&
 str,
- 
+ 
 ios_base::openmode which = ios_base::out|ios_base::in);
- 
+ 
 basic_stringstream(basic_stringstream&& rhs);
- 
+ 

- //
+ //
 27.7.5.1 Assign/swap:
- 
+ 
 void swap(basic_stringstream&& rhs);
- 
+ 

- //
+ //
 Members:
- 
+ 
 basic_stringbuf<charT,traits,Alloc>* rdbuf()
 const;
- 
+ 
 basic_string<charT,traits,Alloc> str() const;
- 
+ 
 void str(const
 basic_string<charT,traits,Alloc>& str);
- 
+ 
 private:
- //
+ //
 basic_stringbuf<charT, traits> sb; exposition only
- };
- 
+ };
+ 

- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_stringstream<charT, traits,
 Alloc>& x,
- 
+ 
 basic_stringstream<charT, traits, Alloc>&
 y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_stringstream<charT, traits,
 Alloc>&& x,
- 
+ 
 basic_stringstream<charT, traits, Alloc>&
 y);
- 
+ 
 template <class charT, class traits, Allocator
 Alloc>
- 
+ 
 void swap(basic_stringstream<charT, traits,
 Alloc>& x,
- 
+ 
 basic_stringstream<charT, traits,
 Alloc>&& y);
- }
+ }
</suggestion>
<notes>
</notes>
@@ -15516,147 +15514,147 @@
 Change to a style of C++.
 
 Correct as follows.
- 
+ 

- 
+ 
 29.1
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 typedef enum memory_order {
- 
+ 
 memory_order_relaxed, memory_order_consume,
 memory_order_acquire,
- 
+ 
 memory_order_release, memory_order_acq_rel,
 memory_order_seq_cst
- }
+ }
 memory_order;
- }
- 
+ }
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 enum memory_order {
- 
+ 
 memory_order_relaxed, memory_order_consume,
 memory_order_acquire,
- 
+ 
 memory_order_release, memory_order_acq_rel,
 memory_order_seq_cst
- };
- }
- 
+ };
+ }
+ 

- 
+ 
 29.3.1
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 typedef struct atomic_bool {
- ...
- }
+ ...
+ }
 atomic_bool;
- }
- 
+ }
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 struct atomic_bool {
- ...
- };
- }
- 
+ ...
+ };
+ }
+ 

- 
+ 
 namespace std {
- 
+ 
 typedef struct atomic_itype {
- ...
- }
+ ...
+ }
 atomic_itype;
- }
- 
+ }
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 struct atomic_itype {
- ...
- };
- }
- 
+ ...
+ };
+ }
+ 

- 
+ 
 29.3.2
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 typedef struct atomic_address {
- ...
- }
+ ...
+ }
 atomic_address;
- }
- 
+ }
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 struct atomic_address {
- ...
- };
- }
- 
+ ...
+ };
+ }
+ 

- 
+ 
 29.5
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 typedef struct atomic_flag {
- ...
- }
+ ...
+ }
 atomic_flag;
- }
- 
+ }
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 namespace std {
- 
+ 
 struct atomic_flag {
- ...
- };
- }
+ ...
+ };
+ }
</suggestion>
<notes>Done
</notes>
@@ -16753,78 +16751,78 @@
</description>
<suggestion>
 Correct as follows.
- 
+ 

- 
+ 
 template <class F>
- 
+ 
 explicit packaged_task(F f);
- 
+ 
 template <class F, class Allocator>
- 
+ 
 explicit packaged_task(allocator_arg_t, const
 Allocator& a, F f);
- 
+ 
 template <class F>
- 
+ 
 explicit packaged_task(F&& f);
- 
+ 
 template <class F, class Allocator>
- 
+ 
 explicit packaged_task(allocator_arg_t, const
 Allocator& a, F&& f);
- 
+ 

- 
+ 
 should be
- 
+ 

- 
+ 
 template <class F>
- 
+ 
 requires CopyConstructible<F> &&
 Callable<F, ArgTypes...>
- 
+ 
 && Convertible<Callable<F,
 ArgTypes...>::result_type, R>
- 
+ 
 explicit packaged_task(F f);
- 
+ 

- 
+ 
 template <class F, Allocator Alloc>
- 
+ 
 requires CopyConstructible<F> &&
 Callable<F, ArgTypes...>
- 
+ 
 && Convertible<Callable<F,
 ArgTypes...>::result_type, R>
- 
+ 
 explicit packaged_task(allocator_arg_t, const
 Alloc& a, F f);
- 
+ 

- 
+ 
 template <class F>
- 
+ 
 requires CopyConstructible<F> &&
 Callable<F, ArgTypes...>
- 
+ 
 && Convertible<Callable<F,
 ArgTypes...>::result_type, R>
- 
+ 
 explicit packaged_task(F&& f);
- 
+ 

- 
+ 
 template <class F, Allocator Alloc>
- 
+ 
 requires CopyConstructible<F> &&
 Callable<F, ArgTypes...>
- 
+ 
 && Convertible<Callable<F,
 ArgTypes...>::result_type, R>
- explicit
+ explicit
 packaged_task(allocator_arg_t, const Alloc& a,
 F&& f);
</suggestion>

Next message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r51846 - sandbox/committee/LWG/cd_status"
Previous message: bdawes_at_[hidden]: "[Boost-commit] svn:boost r51844 - sandbox/committee/LWG/cd_status"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk