From 78d731a73ab6e8dbd076e968376bff11a621a633 Mon Sep 17 00:00:00 2001 From: paolo Date: Fri, 11 Dec 2009 17:23:09 +0000 Subject: 2009-12-11 Paolo Carlini * doc/html/ext/lwg-active.html: Update to Revision R68. * doc/html/ext/lwg-closed.html: Likewise. * doc/html/ext/lwg-defects.html: Likewise. * doc/xml/manual/intro.xml: Update status of issues 431, 630, and 696. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@155170 138bc75d-0d04-0410-961f-82ee72b054a4 --- libstdc++-v3/doc/html/ext/lwg-active.html | 38383 ++++++++++++--------------- libstdc++-v3/doc/html/ext/lwg-closed.html | 20304 +++++++++++--- libstdc++-v3/doc/html/ext/lwg-defects.html | 5227 +++- 3 files changed, 38393 insertions(+), 25521 deletions(-) (limited to 'libstdc++-v3/doc/html') diff --git a/libstdc++-v3/doc/html/ext/lwg-active.html b/libstdc++-v3/doc/html/ext/lwg-active.html index 74e43ef277c..15281f31ff8 100644 --- a/libstdc++-v3/doc/html/ext/lwg-active.html +++ b/libstdc++-v3/doc/html/ext/lwg-active.html @@ -7,6 +7,14 @@ @@ -14,11 +22,11 @@ del {background-color:#FFA0A0} - + - + @@ -29,7 +37,7 @@ del {background-color:#FFA0A0}
Doc. no.N2940=09-0130N3011=09-0201
Date:2009-08-022009-11-08
Project:Howard Hinnant <howard.hinnant@gmail.com>
-

C++ Standard Library Active Issues List (Revision R66)

+

C++ Standard Library Active Issues List (Revision R68)

Reference ISO/IEC IS 14882:2003(E)

Also see:

@@ -82,9 +90,139 @@ del {background-color:#FFA0A0} can be found in the comp.std.c++ FAQ.

+

How to submit an issue

+ +
    +
  1. +Mail your issue to the author of this list. +
    2. +
  2. +Specify a short descriptive title. If you fail to do so, the subject line of your +mail will be used as the issue title. +
    3. +
  3. +If the "From" on your email is not the name you wish to appear as issue submitter, +then specify issue submitter. +
    4. +
  4. +Provide a brief discussion of the problem you wish to correct. Refer to the latest +working draft or standard using [section.tag] and paragraph numbers where appropriate. +
    5. +
  5. +Provide proposed wording. This should indicate exactly how you want the standard +to be changed. General solution statements belong in the discussion area. This +area contains very clear and specific directions on how to modify the current +draft. If you are not sure how to word a solution, you may omit this part. +But your chances of a successful issue greatly increase if you attempt wording. +
    6. +
  6. +It is not necessary for you to use html markup. However, if you want to, you can +<ins>insert text like this</ins> and <del>delete text like +this</del>. The only strict requirement is to communicate clearly to +the list maintainer exactly how you want your issue to look. +
    7. +
  7. +It is not necessary for you to specify other html font/formatting +mark-up, but if you do the list maintainer will attempt to respect your +formatting wishes (as described by html markup, or other common idioms). +
    8. +
  8. +It is not necessary for you to specify open date or last modified date (the date +of your mail will be used). +
    9. +
  9. +It is not necessary for you to cross reference other issues, but you can if you +like. You do not need to form the hyperlinks when you do, the list maintainer will +take care of that. +
    10. +
  10. +One issue per email is best. +
    11. +
  11. +Between the time you submit the issue, and the next mailing deadline +(date at the top of the Revision History), you own this issue. +You control the content, the stuff that is right, the stuff that is +wrong, the format, the misspellings, etc. You can even make the issue +disappear if you want. Just let the list maintainer know how you want +it to look, and he will try his best to accommodate you. After the +issue appears in an official mailing, you no longer enjoy exclusive +ownership of it. +
    12. +
+

Revision History

@@ -146,24 +284,24 @@ del {background-color:#FFA0A0}
  • 1143 issues total, up by 32.
  • Details:
    • @@ -176,7 +314,7 @@ del {background-color:#FFA0A0}
  • 1111 issues total, up by 19.
  • Details:
    • @@ -193,9 +331,9 @@ del {background-color:#FFA0A0}
  • Details:
    • @@ -226,7 +364,7 @@ del {background-color:#FFA0A0}
  • 982 issues total, up by 44.
  • Details:
    • @@ -239,7 +377,7 @@ del {background-color:#FFA0A0}
  • 938 issues total, up by 20.
  • Details:
    • @@ -253,28 +391,28 @@ del {background-color:#FFA0A0}
  • Details:
    • @@ -288,7 +426,7 @@ del {background-color:#FFA0A0}
  • 878 issues total, up by 9.
  • Details:
    • @@ -319,21 +457,21 @@ del {background-color:#FFA0A0}
  • Details:
  • Details:
    • @@ -365,7 +503,7 @@ del {background-color:#FFA0A0}
  • Details:
  • Details:
    • Added the following New issues: 755, 756, 757, 758, 759, 760, 761, 762, 763, 764.
      • -
    • Changed the following issues from NAD to Open: 463.
      • +
    • Changed the following issues from NAD to Open: 463.
    • Changed the following issues from Pending WP to WP: 607, 608, 654, 655, 677, 682.
    • @@ -436,7 +574,7 @@ del {background-color:#FFA0A0}
  • Changed the following issues from NAD Future to Dup: 77, 350.
  • Changed the following issues from New to NAD: 639, 657, 663.
  • Changed the following issues from Open to NAD: 548.
    • -
  • Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
    • +
  • Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
  • Changed the following issues from New to Pending NAD Editorial: 393, 592.
  • Changed the following issues from New to Pending WP: 607, 608, 654, 655, 677, 682.
  • Changed the following issues from New to Ready: 561, 562, 563, 567, 581, 595, 620, 621, 622, 623, 624, 661, 664, 665, 666, 674, 675, 676, 679, 687, 688, 689, 693, 694, 695, 700, 703, 705, 706.
    • @@ -457,7 +595,7 @@ del {background-color:#FFA0A0}
  • 723 issues total, up by 15.
  • Details:
    • @@ -497,7 +635,7 @@ del {background-color:#FFA0A0}
  • 696 issues total, up by 20.
  • Details:
  • Details:
  • Details:
    • @@ -559,7 +697,7 @@ del {background-color:#FFA0A0}
  • 619 issues total, up by 10.
  • Details:
    • @@ -591,7 +729,7 @@ del {background-color:#FFA0A0}
  • 592 issues total, up by 5.
  • Details:
    • @@ -604,7 +742,7 @@ del {background-color:#FFA0A0}
  • 587 issues total, up by 13.
  • Details:
    • @@ -621,7 +759,7 @@ del {background-color:#FFA0A0}
  • Details:
  • Details:
    • @@ -652,7 +790,7 @@ del {background-color:#FFA0A0}
  • 535 issues total.
  • Details:
    • @@ -661,7 +799,7 @@ del {background-color:#FFA0A0} Added new issues 526-528. Moved issues 280, 461, 464, 465, 467, 468, 474, 496 from Ready to WP as per the vote from Mont Tremblant. Moved issues 247, 294, 342, 362, 369, 371, 376, 384, 475, 478, 495, 497 from Review to Ready. -Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open. +Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open. Moved issues 505, 507, 508, 519 from New to Ready. Moved issue 500 from New to NAD. Moved issue 518 from New to Review. @@ -673,7 +811,7 @@ Added new issues 498-503. +Added new issues 498-503.
  • R36: 2005-04 post-Lillehammer mailing. All issues in "ready" status except @@ -697,7 +835,7 @@ new issues 463-478. +new issues 463-478.
  • R30: Post-Sydney mailing: reflects decisions made at the Sydney meeting. @@ -712,7 +850,7 @@ Post-Kona mailing: reflects decisions made at the Kona meeting. Added new issues 432-440.
  • R27: -Pre-Kona mailing. Added new issues 404-431. +Pre-Kona mailing. Added new issues 404-431.
  • R26: Post-Oxford mailing: reflects decisions made at the Oxford meeting. @@ -1007,690 +1145,294 @@ format, 96. Vector<bool> is not a container -

    Section: 23.3.6 [vector] Status: Open - Submitter: AFNOR Opened: 1998-10-07 Last modified: 2009-07-29

    -

    View other active issues in [vector].

    -

    View all other issues in [vector].

    -

    View all issues with Open status.

    +

    296. Missing descriptions and requirements of pair operators

    +

    Section: 20.3.4 [pairs] Status: Ready + Submitter: Martin Sebor Opened: 2001-01-14 Last modified: 2009-10-26

    +

    View other active issues in [pairs].

    +

    View all other issues in [pairs].

    +

    View all issues with Ready status.

    Discussion:

    -

    vector<bool> is not a container as its reference and -pointer types are not references and pointers.

    - -

    Also it forces everyone to have a space optimization instead of a -speed one.

    - -

    See also: 99-0008 == N1185 Vector<bool> is -Nonconforming, Forces Optimization Choice.

    - -

    [In Santa Cruz the LWG felt that this was Not A Defect.]

    - - -

    [In Dublin many present felt that failure to meet Container -requirements was a defect. There was disagreement as to whether -or not the optimization requirements constituted a defect.]

    - - -

    [The LWG looked at the following resolutions in some detail: -
    -     * Not A Defect.
    -     * Add a note explaining that vector<bool> does not meet -Container requirements.
    -     * Remove vector<bool>.
    -     * Add a new category of container requirements which -vector<bool> would meet.
    -     * Rename vector<bool>.
    -
    -No alternative had strong, wide-spread, support and every alternative -had at least one "over my dead body" response.
    -
    -There was also mention of a transition scheme something like (1) add -vector_bool and deprecate vector<bool> in the next standard. (2) -Remove vector<bool> in the following standard.]

    - - -

    [Modifying container requirements to permit returning proxies -(thus allowing container requirements conforming vector<bool>) -was also discussed.]

    - - -

    [It was also noted that there is a partial but ugly workaround in -that vector<bool> may be further specialized with a customer -allocator.]

    - - -

    [Kona: Herb Sutter presented his paper J16/99-0035==WG21/N1211, -vector<bool>: More Problems, Better Solutions. Much discussion -of a two step approach: a) deprecate, b) provide replacement under a -new name. LWG straw vote on that: 1-favor, 11-could live with, 2-over -my dead body. This resolution was mentioned in the LWG report to the -full committee, where several additional committee members indicated -over-my-dead-body positions.]

    - - -

    Discussed at Lillehammer. General agreement that we should - deprecate vector<bool> and introduce this functionality under - a different name, e.g. bit_vector. This might make it possible to - remove the vector<bool> specialization in the standard that comes - after C++0x. There was also a suggestion that - in C++0x we could additional say that it's implementation defined - whether vector<bool> refers to the specialization or to the - primary template, but there wasn't general agreement that this was a - good idea.

    - -

    We need a paper for the new bit_vector class.

    - -

    [ -Batavia: -]

    - -
    -The LWG feels we need something closer to SGI's bitvector to ease migration -from vector<bool>. Although some of the funcitonality from -N2050 -could well be used in such a template. The concern is easing the API migration for those -users who want to continue using a bit-packed container. Alan and Beman to work. -
    +

    The synopsis of the header <utility> in 20.3 [utility] +lists the complete set of equality and relational operators for pair +but the section describing the template and the operators only describes +operator==() and operator<(), and it fails to mention +any requirements on the template arguments. The remaining operators are +not mentioned at all. +

    [ -Post Summit Alisdair adds: +2009-09-27 Alisdair reopens. ]

    -vector<bool> is now a conforming container under the revised terms of C++0x, -which supports containers of proxies. +The issue is a lack of wording specifying the semantics of std::pair +relational operators. The rationale is that this is covered by +catch-all wording in the relops component, and that as relops directly +precedes pair in the document this is an easy connection to make.

    +

    -Recommend NAD. +Reading the current working paper I make two observations:

    + +
      +
    1. +relops no longer immediately precedes pair in the order of +specification. However, even if it did, there is a lot of pair +specification itself between the (apparently) unrelated relops and the +relational operators for pair. (The catch-all still requires +operator== and operator< to be specified +explicitly) +
      2. + +
    2. +No other library component relies on the catch-all clause. The following +all explicitly document all six relational operators, usually in a +manner that could have deferred to the relops clause. +
      3. +
    + +
    tuple
+unique_ptr
+duration
+time_point
+basic_string
+queue
+stack
+move_iterator
+reverse_iterator 
+regex submatch
+thread::id
+
    +

    -Two issues remain: +The container components provide their own (equivalent) definition in +23.2.1 [container.requirements.general] Table 90 -- Container +requirements and do so do not defer to relops.

    +

    -i/ premature optimization in the specification. -There is still some sentiment that deprecation is the correct way to go, -although it is still not clear what it would mean to deprecate a single -specialization of a template. +Shared_ptr explicitly documents operator!= and does +not supply the other 3 missing operators +(>,>=,<=) so does not meet the +reqirements of the relops clause.

    +

    -Recommend: Create a new issue for the discussion, leave as Open. +Weak_ptr only supports operator< so would not be +covered by relops.

    +

    -ii/ Request for a new bitvector class to guarantee the optimization, perhaps -with a better tuned interface. +At the very least I would request a note pointing to the relops clause +we rely on to provide this definition. If this route is taken, I would +recommend reducing many of the above listed clauses to a similar note +rather than providing redundant specification.

    +

    -This is a clear extension request that may be handled via a future TR. +My preference would be to supply the 4 missing specifications consistent +with the rest of the library.

    +

    [ -Batavia (2009-05): +2009-10-11 Daniel opens 1233 which deals with the same issue as +it pertains to unique_ptr. ]

    -
    -We note that most of this issue has become moot over time, -and agree with Alisdair's recommendations. -Move to NAD Future for reconsideration of part (ii). -

    [ -2009-07-29 Alisdair reopens: +2009-10 Santa Cruz: ]

    -

    -This infamous issue was closed as NAD Future when concepts introduced -support for proxy iterators, so the only remaining requirement was to -provide a better type to support bitsets of dynamic length. I fear we -must re-open this issue until the post-concept form of iterators is -available, and hopefully will support the necessary proxy functionality -to allow us to close this issue as NAD. -

    - -

    -I recommend we spawn a separate issue (1184) requesting a dynamic length bitset -and pre-emptively file it as NAD Future. It is difficult to resolve #96 -when it effectively contains two separate sub-issues. -

    +Move to Ready
    +

    Proposed resolution:

    -We now have: -N2050 -and -N2160. +After p20 20.3.4 [pairs] add:

    - - - - - -
    -

    149. Insert should return iterator to first element inserted

    -

    Section: 23.2.3 [sequence.reqmts] Status: Ready - Submitter: Andrew Koenig Opened: 1999-06-28 Last modified: 2009-07-15

    -

    View all other issues in [sequence.reqmts].

    -

    View all issues with Ready status.

    -

    Discussion:

    -

    Suppose that c and c1 are sequential containers and i is an -iterator that refers to an element of c. Then I can insert a copy of -c1's elements into c ahead of element i by executing

    +
    template <class T1, class T2>
+bool operator!=(const pair<T1,T2>& x, const pair<T1,T2>& y);
+
    - -
    c.insert(i, c1.begin(), c1.end());
    - +Returns: !(x==y)
    -

    If c is a vector, it is fairly easy for me to find out where the -newly inserted elements are, even though i is now invalid:

    +
    template <class T1, class T2>
+bool operator> (const pair<T1,T2>& x, const pair<T1,T2>& y);
+
    - -
    size_t i_loc = i - c.begin();
-c.insert(i, c1.begin(), c1.end());
    - +Returns: y < x
    -

    and now the first inserted element is at c.begin()+i_loc and one -past the last is at c.begin()+i_loc+c1.size().
    -
    -But what if c is a list? I can still find the location of one past the -last inserted element, because i is still valid. To find the location -of the first inserted element, though, I must execute something like

    +
    template <class T1, class T2>
+bool operator>=(const pair<T1,T2>& x, const pair<T1,T2>& y);
+
    - -
    for (size_t n = c1.size(); n; --n)
-   --i;
    - +Returns: !(x < y)
    -

    because i is now no longer a random-access iterator.
    -
    -Alternatively, I might write something like

    +
    template <class T1, class T2>
+bool operator<=(const pair<T1,T2>& x, const pair<T1,T2>& y);
+
    - -
    bool first = i == c.begin();
-list<T>::iterator j = i;
-if (!first) --j;
-c.insert(i, c1.begin(), c1.end());
-if (first)
-   j = c.begin();
-else
-   ++j;
    - +Returns: !(y < x) +
    -

    which, although wretched, requires less overhead.
    -
    -But I think the right solution is to change the definition of insert -so that instead of returning void, it returns an iterator that refers -to the first element inserted, if any, and otherwise is a copy of its -first argument. 

    -

    [ -Summit: -]

    +

    Rationale:

    +

    20.3.1 [operators] paragraph 10 already specifies the semantics. +That paragraph says that, if declarations of operator!=, operator>, +operator<=, and operator>= appear without definitions, they are +defined as specified in 20.3.1 [operators]. There should be no user +confusion, since that paragraph happens to immediately precede the +specification of pair.

    -
    -Reopened by Alisdair. -
    -

    [ -Post Summit Alisdair adds: -]

    -
    +
    +

    299. Incorrect return types for iterator dereference

    +

    Section: 24.2.4 [bidirectional.iterators], 24.2.5 [random.access.iterators] Status: Open + Submitter: John Potter Opened: 2001-01-22 Last modified: 2009-10-26

    +

    View all other issues in [bidirectional.iterators].

    +

    View all issues with Open status.

    +

    Discussion:

    -In addition to the original rationale for C++03, this change also gives a -consistent interface for all container insert operations i.e. they all -return an iterator to the (first) inserted item. +In section 24.2.4 [bidirectional.iterators], +Table 75 gives the return type of *r-- as convertible to T. This is +not consistent with Table 74 which gives the return type of *r++ as +T&. *r++ = t is valid while *r-- = t is invalid.

    -Proposed wording provided. +In section 24.2.5 [random.access.iterators], +Table 76 gives the return type of a[n] as convertible to T. This is +not consistent with the semantics of *(a + n) which returns T& by +Table 74. *(a + n) = t is valid while a[n] = t is invalid.

    -
    - -

    [ -2009-07 Frankfurt -]

    - -

    -Q: why isn't this change also proposed for associative containers? +Discussion from the Copenhagen meeting: the first part is +uncontroversial. The second part, operator[] for Random Access +Iterators, requires more thought. There are reasonable arguments on +both sides. Return by value from operator[] enables some potentially +useful iterators, e.g. a random access "iota iterator" (a.k.a +"counting iterator" or "int iterator"). There isn't any obvious way +to do this with return-by-reference, since the reference would be to a +temporary. On the other hand, reverse_iterator takes an +arbitrary Random Access Iterator as template argument, and its +operator[] returns by reference. If we decided that the return type +in Table 76 was correct, we would have to change +reverse_iterator. This change would probably affect user +code.

    -A: The returned iterator wouldn't necessarily point to a contiguous range. +History: the contradiction between reverse_iterator and the +Random Access Iterator requirements has been present from an early +stage. In both the STL proposal adopted by the committee +(N0527==94-0140) and the STL technical report (HPL-95-11 (R.1), by +Stepanov and Lee), the Random Access Iterator requirements say that +operator[]'s return value is "convertible to T". In N0527 +reverse_iterator's operator[] returns by value, but in HPL-95-11 +(R.1), and in the STL implementation that HP released to the public, +reverse_iterator's operator[] returns by reference. In 1995, the +standard was amended to reflect the contents of HPL-95-11 (R.1). The +original intent for operator[] is unclear.

    -Moved to Ready. +In the long term it may be desirable to add more fine-grained +iterator requirements, so that access method and traversal strategy +can be decoupled. (See "Improved Iterator Categories and +Requirements", N1297 = 01-0011, by Jeremy Siek.) Any decisions +about issue 299 should keep this possibility in mind.

    -
    - +

    Further discussion: I propose a compromise between John Potter's +resolution, which requires T& as the return type of +a[n], and the current wording, which requires convertible to +T. The compromise is to keep the convertible to T +for the return type of the expression a[n], but to also add +a[n] = t as a valid expression. This compromise "saves" the +common case uses of random access iterators, while at the same time +allowing iterators such as counting iterator and caching file +iterators to remain random access iterators (iterators where the +lifetime of the object returned by operator*() is tied to the +lifetime of the iterator). +

    -

    Proposed resolution:

    - Table 83 -change return type from void to iterator for the following rows: -

    - -
    - - - - - - - - - - - - - - - - - - - - - - - - -
    Table 83 -- Sequence container requirements (in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-condition
    -a.insert(p,n,t) - -void iterator - -Inserts n copies of t before p. -
    -a.insert(p,i,j) - -void iterator - -Each iterator in the range [i,j) shall be -dereferenced exactly once. -pre: i and j are not iterators into a. -Inserts copies of elements in [i, j) before p -
    -a.insert(p,il) - -void iterator - -a.insert(p, il.begin(), il.end()). -
    -
    +Note that the compromise resolution necessitates a change to +reverse_iterator. It would need to use a proxy to support +a[n] = t. +

    -Add after p6 23.2.3 [sequence.reqmts]: +Note also there is one kind of mutable random access iterator that +will no longer meet the new requirements. Currently, iterators that +return an r-value from operator[] meet the requirements for a +mutable random access iterartor, even though the expression a[n] = +t will only modify a temporary that goes away. With this proposed +resolution, a[n] = t will be required to have the same +operational semantics as *(a + n) = t.

    -
    -

    -6- ...

    - -

    -The iterator returned from a.insert(p,n,t) points to the copy of the -first element inserted into a, or p if n == 0. -

    +

    [ +2009-07-28 Reopened by Alisdair. No longer solved by concepts. +]

    -

    -The iterator returned from a.insert(p,i,j) points to the copy of the -first element inserted into a, or p if i == j. -

    -

    -The iterator returned from a.insert(p,il) points to the copy of the -first element inserted into a, or p if il is empty. -

    +

    [ +2009-09-18 Alisdair adds: +]

    -
    +

    -p2 23.3.2 [deque] Update class definition, change return type -from void to iterator: +Why can't we write through the reference returned from operator[] on a +random access iterator?

    -
    void iterator insert(const_iterator position, size_type n, const T& x);
-template <class InputIterator>
-  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-  void iterator insert(const_iterator position, initializer_list<T>);
-
    -

    -23.3.2.3 [deque.modifiers] change return type from void to iterator on following declarations: +Recommended solution:

    -
      void iterator insert(const_iterator position, size_type n, const T& x);
-template <class InputIterator>
-  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-
    -

    -Add the following (missing) declaration +In table Table 104 -- Random access iterator requirements, replace

    -
    iterator insert(const_iterator position, initializer_list<T>);
-
    +
    +a[n] : convertible to const T & +T& if X is mutable, otherwise convertible to const T& +
    +
    -

    -23.3.3 [forwardlist] Update class definition, change return type -from void to iterator: -

    +

    [ +2009-10 Santa Cruz: +]

    -
    void iterator insert_after(const_iterator position, initializer_list<T> il);
-void iterator insert_after(const_iterator position, size_type n, const T& x);
-template <class InputIterator>
-  void iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
-
    - -

    -p8 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator: -

    - -
    void iterator insert_after(const_iterator position, size_type n, const T& x);
-
    - -

    -Add paragraph: -

    - -
    -Returns: position. -
    - -

    -p10 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator: -

    - -
    template <class InputIterator>
-  void iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
-
    - -

    -Add paragraph: -

    - -
    -Returns: position. -
    - -

    -p12 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator on following declarations: -

    - -
    void iterator insert_after(const_iterator position, initializer_list<T> il);
-
    - -

    -change return type from void to iterator on following declarations: -

    - -

    -p2 23.3.4 [list] Update class definition, change return type from void to iterator: -

    - -
    void iterator insert(const_iterator position, size_type n, const T& x);
-
-template <class InputIterator>
-void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-
-void iterator insert(const_iterator position, initializer_list<T>);
-
    - -

    -23.3.4.3 [list.modifiers] change return type from void to iterator on following declarations: -

    - -
    void iterator insert(const_iterator position, size_type n, const T& x);
-
-template <class InputIterator>
-  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-
    - -

    -Add the following (missing) declaration -

    - -
    iterator insert(const_iterator position, initializer_list<T>);
-
    - -

    -p2 23.3.6 [vector] -

    - -

    -Update class definition, change return type from void to iterator: -

    - -
    void iterator insert(const_iterator position, T&& x);
-
-void iterator insert(const_iterator position, size_type n, const T& x);
-
-template <class InputIterator>
-  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-
-void iterator insert(const_iterator position, initializer_list<T>);
-
    - -

    -23.3.6.4 [vector.modifiers] change return type from void to iterator on following declarations: -

    - -
    void iterator insert(const_iterator position, size_type n, const T& x);
-
-template <class InputIterator>
-  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-
    - -

    -Add the following (missing) declaration -

    - -
    iterator insert(const_iterator position, initializer_list<T>);
-
    - - -

    -p1 23.3.7 [vector.bool] Update class definition, change return type from void to iterator: -

    - -
    void iterator insert (const_iterator position, size_type n, const bool& x);
-
-template <class InputIterator>
-  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
-
-  void iterator insert(const_iterator position, initializer_list<bool> il);
-
    - -

    -p5 21.4 [basic.string] Update class definition, change return type from void to iterator: -

    - -
    void iterator insert(const_iterator p, size_type n, charT c);
-
-template<class InputIterator>
-  void iterator insert(const_iterator p, InputIterator first, InputIterator last);
-
-void iterator insert(const_iterator p, initializer_list<charT>);
-
    - -

    -p13 21.4.6.4 [string::insert] change return type from void to iterator: -

    - -
    void iterator insert(const_iterator p, size_type n, charT c);
-
    - -

    -Add paragraph: -

    - -
    -Returns: an iterator which refers to the copy of the first inserted -character, or p if n == 0. -
    - -

    -p15 21.4.6.4 [string::insert] change return type from void to iterator: -

    - -
    template<class InputIterator>
-  void iterator insert(const_iterator p, InputIterator first, InputIterator last);
-
    - -

    -Add paragraph: -

    - -
    -Returns: an iterator which refers to the copy of the first inserted -character, or p if first == last. -
    - -

    -p17 21.4.6.4 [string::insert] change return type from void to iterator: -

    - -
    void iterator insert(const_iterator p, initializer_list<charT> il);
-
    - -

    -Add paragraph: -

    - -
    -Returns: an iterator which refers to the copy of the first inserted -character, or p if il is empty. -
    - - - -

    Rationale:

    - -

    [ -The following was the C++98/03 rationale and does not necessarily apply to the -proposed resolution in the C++0X time frame: -]

    - - -
    -

    The LWG believes this was an intentional design decision and so is -not a defect. It may be worth revisiting for the next standard.

    -
    - - - - -
    -

    299. Incorrect return types for iterator dereference

    -

    Section: 24.2.5 [bidirectional.iterators], 24.2.6 [random.access.iterators] Status: Open - Submitter: John Potter Opened: 2001-01-22 Last modified: 2009-07-28

    -

    View all other issues in [bidirectional.iterators].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    -In section 24.2.5 [bidirectional.iterators], -Table 75 gives the return type of *r-- as convertible to T. This is -not consistent with Table 74 which gives the return type of *r++ as -T&. *r++ = t is valid while *r-- = t is invalid. -

    - -

    -In section 24.2.6 [random.access.iterators], -Table 76 gives the return type of a[n] as convertible to T. This is -not consistent with the semantics of *(a + n) which returns T& by -Table 74. *(a + n) = t is valid while a[n] = t is invalid. -

    - -

    -Discussion from the Copenhagen meeting: the first part is -uncontroversial. The second part, operator[] for Random Access -Iterators, requires more thought. There are reasonable arguments on -both sides. Return by value from operator[] enables some potentially -useful iterators, e.g. a random access "iota iterator" (a.k.a -"counting iterator" or "int iterator"). There isn't any obvious way -to do this with return-by-reference, since the reference would be to a -temporary. On the other hand, reverse_iterator takes an -arbitrary Random Access Iterator as template argument, and its -operator[] returns by reference. If we decided that the return type -in Table 76 was correct, we would have to change -reverse_iterator. This change would probably affect user -code. -

    - -

    -History: the contradiction between reverse_iterator and the -Random Access Iterator requirements has been present from an early -stage. In both the STL proposal adopted by the committee -(N0527==94-0140) and the STL technical report (HPL-95-11 (R.1), by -Stepanov and Lee), the Random Access Iterator requirements say that -operator[]'s return value is "convertible to T". In N0527 -reverse_iterator's operator[] returns by value, but in HPL-95-11 -(R.1), and in the STL implementation that HP released to the public, -reverse_iterator's operator[] returns by reference. In 1995, the -standard was amended to reflect the contents of HPL-95-11 (R.1). The -original intent for operator[] is unclear. -

    - -

    -In the long term it may be desirable to add more fine-grained -iterator requirements, so that access method and traversal strategy -can be decoupled. (See "Improved Iterator Categories and -Requirements", N1297 = 01-0011, by Jeremy Siek.) Any decisions -about issue 299 should keep this possibility in mind. -

    - -

    Further discussion: I propose a compromise between John Potter's -resolution, which requires T& as the return type of -a[n], and the current wording, which requires convertible to -T. The compromise is to keep the convertible to T -for the return type of the expression a[n], but to also add -a[n] = t as a valid expression. This compromise "saves" the -common case uses of random access iterators, while at the same time -allowing iterators such as counting iterator and caching file -iterators to remain random access iterators (iterators where the -lifetime of the object returned by operator*() is tied to the -lifetime of the iterator). -

    - -

    -Note that the compromise resolution necessitates a change to -reverse_iterator. It would need to use a proxy to support -a[n] = t. -

    - -

    -Note also there is one kind of mutable random access iterator that -will no longer meet the new requirements. Currently, iterators that -return an r-value from operator[] meet the requirements for a -mutable random access iterartor, even though the expression a[n] = -t will only modify a temporary that goes away. With this proposed -resolution, a[n] = t will be required to have the same -operational semantics as *(a + n) = t. -

    - -

    [ -2009-07-28 Reopened by Alisdair. No longer solved by concepts. -]

    +
    +Leave Open. Alisdair to spearhead a paper on revivification. +
    @@ -1725,7 +1467,7 @@ San Francisco:
    Solved by -N2758. +N2758.
    @@ -1736,10 +1478,10 @@ Solved by

    397. ostream::sentry dtor throws exceptions

    -

    Section: 27.7.2.4 [ostream::sentry] Status: Review - Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2009-07-14

    +

    Section: 27.7.2.4 [ostream::sentry] Status: Open + Submitter: Martin Sebor Opened: 2003-01-05 Last modified: 2009-10-20

    View all other issues in [ostream::sentry].

    -

    View all issues with Review status.

    +

    View all issues with Open status.

    Discussion:

    17.4.4.8, p3 prohibits library dtors from throwing exceptions. @@ -1788,6 +1530,25 @@ Move to Review. Add "Throws: nothing" to the specification of ostream::sentry::~

    +

    [ +2009-10-13 Daniel adds: +]

    + + +
    +The proposed resolution of 835 is written to match the outcome +of this issue. +
    + +

    [ +2009 Santa Cruz: +]

    + + +
    +Move to Open. Our intent is to solve this issue with 835. +
    +

    Proposed resolution:

    @@ -1816,11 +1577,11 @@ is true, calls os.flush().

    408. Is vector<reverse_iterator<char*> > forbidden?

    -

    Section: 24.2 [iterator.concepts] Status: Review - Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2009-07-31

    -

    View other active issues in [iterator.concepts].

    -

    View all other issues in [iterator.concepts].

    -

    View all issues with Review status.

    +

    Section: 24.2 [iterator.requirements] Status: Open + Submitter: Nathan Myers Opened: 2003-06-03 Last modified: 2009-11-03

    +

    View other active issues in [iterator.requirements].

    +

    View all other issues in [iterator.requirements].

    +

    View all issues with Open status.

    Discussion:

    I've been discussing iterator semantics with Dave Abrahams, and a @@ -1828,7 +1589,7 @@ surprise has popped up. I don't think this has been discussed before.

    -24.2 [iterator.concepts] says that the only operation that can be performed on "singular" +X [iterator.concepts] says that the only operation that can be performed on "singular" iterator values is to assign a non-singular value to them. (It doesn't say they can be destroyed, and that's probably a defect.) Some implementations have taken this to imply that there is no need @@ -1926,7 +1687,7 @@ are default-initialized, and it should explicitly allow destroying any iterator value, singular or not, default-initialized or not.

    -

    Related issues: 407, 1012

    +

    Related issues: 407, 1012

    [ We don't want to require all singular iterators to be copyable, because that is not the case for pointers. However, default @@ -1955,18 +1716,18 @@ resolved. That just leaves copying (with moving implied).

    -This is related to LWG 1012. +This is related to LWG 1012.

    -Note that there is a bug in the proposed resolution to LWG 1012. The +Note that there is a bug in the proposed resolution to LWG 1012. The change to [reverse.iter.con] should be modified so that the word "default" in the second sentence of the Effects clause is replaced by "value."

    -We believe that the proposed fix to LWG 1012 (now corrected) is +We believe that the proposed fix to LWG 1012 (now corrected) is sufficient to solve the problem for reverse_iterator. However, Alisdair -pointed out that LWG 1012 does not solve the general problem for authors +pointed out that LWG 1012 does not solve the general problem for authors of iterator adaptors.

    @@ -1984,12 +1745,38 @@ Move to Review after Alisdair updates the wording. ]

    +

    [ +2009-08-17 Alisdair and Daniel collaborate on slightly revised wording. +This issue depends upon 724 +]

    + + +

    [ +2009-10-14 Daniel adds: +]

    + + +
    +There is a clear dependency on 1213, because the term "singular", +which is used as part of the resolution, is not properly defined yet. +
    + +

    [ +2009-10 Santa Cruz: +]

    + + +
    +Moved to Open. Alisdair will provide improved wording to make +this have "value semantics" and otherwise behave like a valid iterator. +
    +

    Proposed resolution:

    -Add a new paragrpah to Iterator concepts 24.2 [iterator.concepts] after para 5 (the one -describing singular iterators) +Add a new paragrpah to Iterator concepts 24.2 [iterator.requirements] after para 5 (the one describing +singular iterators)

    @@ -2011,8 +1798,9 @@ Dereferenceable values are always non-singular.

    After value-initialization, any iterator that satisfies the -DefaultConstructible concept shall not introduce undefined behaviour -when used the source of a copy or move operation, even if it would +DefaultConstructible requirements ([defaultconstructible]) shall not introduce undefined behaviour +when used as the +source of a copy or move operation, even if it would otherwise be singular. [Note: This guarantee is not offered for default-initialization (8.5 [dcl.init]), although the distinction only matters for types with trivial default constructors such as pointers. — @@ -2027,128 +1815,10 @@ matters for types with trivial default constructors such as pointers. — -

    -

    419. istream extractors not setting failbit if eofbit is already set

    -

    Section: 27.7.1.1.3 [istream::sentry] Status: Ready - Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-07-14

    -

    View all other issues in [istream::sentry].

    -

    View all issues with Ready status.

    -

    Discussion:

    -

    - -27.7.1.1.3 [istream::sentry], p2 says that istream::sentry ctor prepares for input if is.good() -is true. p4 then goes on to say that the ctor sets the sentry::ok_ member to -true if the stream state is good after any preparation. 27.7.1.2.1 [istream.formatted.reqmts], p1 then -says that a formatted input function endeavors to obtain the requested input -if the sentry's operator bool() returns true. - -Given these requirements, no formatted extractor should ever set failbit if -the initial stream rdstate() == eofbit. That is contrary to the behavior of -all implementations I tested. The program below prints out - -eof = 1, fail = 0 -eof = 1, fail = 1 - -on all of them. -

    -
    -#include <sstream>
-#include <cstdio>
-
-int main()
-{
-    std::istringstream strm ("1");
-
-    int i = 0;
-
-    strm >> i;
-
-    std::printf ("eof = %d, fail = %d\n",
-                 !!strm.eof (), !!strm.fail ());
-
-    strm >> i;
-
-    std::printf ("eof = %d, fail = %d\n",
-                 !!strm.eof (), !!strm.fail ());
-}
-
-
    -

    -
    - -Comments from Jerry Schwarz (c++std-lib-11373): -
    - -Jerry Schwarz wrote: -
    - -I don't know where (if anywhere) it says it in the standard, but the -formatted extractors are supposed to set failbit if they don't extract -any characters. If they didn't then simple loops like -
    - -while (cin >> x); -
    - -would loop forever. -
    - -Further comments from Martin Sebor: -
    - -The question is which part of the extraction should prevent this from happening -by setting failbit when eofbit is already set. It could either be the sentry -object or the extractor. It seems that most implementations have chosen to -set failbit in the sentry [...] so that's the text that will need to be -corrected. - -

    -

    -Pre Berlin: This issue is related to 342. If the sentry -sets failbit when it finds eofbit already set, then -you can never seek away from the end of stream. -

    -

    Kona: Possibly NAD. If eofbit is set then good() will return false. We - then set ok to false. We believe that the sentry's - constructor should always set failbit when ok is false, and - we also think the standard already says that. Possibly it could be - clearer.

    - - -

    [ -2009-07 Frankfurt -]

    - - -
    -Moved to Ready. -
    - - - -

    Proposed resolution:

    -

    -Change 27.7.1.1.3 [istream::sentry], p2 to: -

    - -
    -
    explicit sentry(basic_istream<charT,traits>& is , bool noskipws = false);
    -

    --2- Effects: If is.good() is true -false, calls is.setstate(failbit). -Otherwise prepares for formatted or unformatted input. ... -

    -
    - - - - - -

    427. stage 2 and rationale of DR 221

    Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: Open - Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-07-14

    + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-10-26

    View other active issues in [facet.num.get.virtuals].

    View all other issues in [facet.num.get.virtuals].

    View all issues with Open status.

    @@ -2233,18 +1903,311 @@ Daniel volunteered to provide wording.

    +

    [ +2009-09-19 Daniel provided wording. +]

    + + +

    [ +2009-10 Santa Cruz: +]

    + + +
    +Leave as Open. Alisdair and/or Tom will provide wording based on discussions. +We want to clearly state that streams and locales work just on char +and wchar_t (except where otherwise specified). +
    +

    Proposed resolution:

    +
      +
    1. +

      +Change 22.3.1.1.1 [locale.category]/6: +

      + +
      +[..] A template formal parameter with name C represents the set of all possible +specializations on a char or wchar_t parameter that satisfies +the requirements for a character on which any of the iostream components +can be instantiated. [..] +
      +
      2. + +
    2. +

      +Add the following sentence to the end of 22.4.2 [category.numeric]/2: +

      + +
      +[..] These specializations refer to [..], and also for the ctype<> facet to +perform character classification. Implementations are encouraged +but not required to use the char_traits<charT> functions for all +comparisons and assignments of characters of type charT that do +not belong to the set of required specializations. +
      +
      3. + +
    3. +

      +Change 22.4.2.1.2 [facet.num.get.virtuals]/3: +

      + +
      +

      +Stage 2: If in==end then stage 2 terminates. Otherwise a charT is taken +from in and local variables are initialized as if by +

      + +
      char_type ct = *in;
+using tr = char_traits<char_type>;
+const char_type* pos = tr::find(atoms, sizeof(src) - 1, ct);
+char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms
+             pos ? pos - atoms : sizeof(src) - 1];
+if (tr::eq(ct, ct == use_facet<numpunct<charT>(loc).decimal_point()))
+    c = '.';
+bool discard =
+    tr::eq(ct, ct == use_facet<numpunct<charT>(loc).thousands_sep())
+    && use_facet<numpunct<charT> >(loc).grouping().length() != 0;
+
      + +

      +where the values src and atoms are defined as if by: [..] +

      +
      + +

      +[Remark of the author: I considered to replace the initialization +"char_type ct = *in;" +by the sequence "char_type ct; tr::assign(ct, *in);", but decided +against it, because +it is a copy-initialization context, not an assignment] +

      +
      4. + +
    4. +

      +Add the following sentence to the end of 22.4.5 [category.time]/1: +

      + +
      +[..] Their members use [..] , to determine formatting details. +Implementations are encouraged but not required to use the +char_traits<charT> functions for all comparisons and assignments +of characters of type charT that do +not belong to the set of required specializations. +
      +
      5. + +
    5. +

      +Change 22.4.5.1.1 [locale.time.get.members]/8 bullet 4: +

      + +
        +
      • +The next element of fmt is equal to '%' For the next element c +of fmt char_traits<char_type>::eq(c, use_facet<ctype<char_type>>(f.getloc()).widen('%')) == true, +[..] +
        • +
      +
      6. + +
    6. +

      +Add the following sentence to the end of 22.4.6 [category.monetary]/2: +

      + +
      +Their members use [..] to determine formatting details. +Implementations are encouraged but not required to use the +char_traits<charT> functions for all comparisons and assignments +of characters of type charT that do +not belong to the set of required specializations. +
      +
      7. + +
    7. +

      +Change 22.4.6.1.2 [locale.money.get.virtuals]/4: +

      + +
      +

      +[..] The value units is produced as if by: +

      + +
      for (int i = 0; i < n; ++i)
+  buf2[i] = src[char_traits<charT>::find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
+buf2[n] = 0;
+sscanf(buf2, "%Lf", &units);
+
      +
      +
      8. + +
    8. +

      +Change 22.4.6.2.2 [locale.money.put.virtuals]/1: +

      + +
      +[..] for character buffers buf1 and buf2. If for the first +character c +in digits or buf2 is equal to +ct.widen('-')char_traits<charT>::eq(c, +ct.widen('-')) == true, [..] +
      +
      9. + +
    9. +

      +Add a footnote to the first sentence of 27.7.1.2.2 [istream.formatted.arithmetic]/1: +

      + +
      +

      +As in the case of the inserters, these extractors depend on the locale's +num_get<> (22.4.2.1) object to perform parsing the input stream +data.(footnote) [..] +

      + +

      + +footnote) If the traits of the input stream has different semantics for lt(), +eq(), and assign() than char_traits<char_type>, this may give surprising +results. + +

      +
      +
      10. + +
    10. +

      +Add a footnote to the second sentence of 27.7.2.6.2 [ostream.inserters.arithmetic]/1: +

      + +
      +

      +Effects: The classes num_get<> and +num_put<> handle locale-dependent numeric formatting and +parsing. These inserter functions use the imbued locale value to perform +numeric formatting.(footnote) [..] +

      + +

      + +footnote) If the traits of the output stream has different semantics for lt(), +eq(), and assign() than char_traits<char_type>, this may give surprising +results. + +

      +
      +
      11. + +
    11. +

      +Add a footnote after the first sentence of 27.7.4 [ext.manip]/4: +

      + +
      +

      +Returns: An object of unspecified type such that if in is an object of type +basic_istream<charT, traits> then the expression in >> get_money(mon, intl) +behaves as if it called f(in, mon, intl), where the function f is defined +as:(footnote) [..] +

      + +

      + +footnote) If the traits of the input stream has different semantics for lt(), +eq(), and assign() than char_traits<char_type>, this may give surprising +results. + +

      +
      +
      12. + +
    12. +

      +Add a footnote after the first sentence of 27.7.4 [ext.manip]/5: +

      + +
      +

      +Returns: An object of unspecified type such that if out is an object of type +basic_ostream<charT, traits> then the expression out << put_money(mon, intl) +behaves as a formatted input function that calls f(out, mon, intl), where the +function f is defined as:(footnote) [..] +

      + +

      + +footnote) If the traits of the output stream has different semantics for lt(), +eq(), and assign() than char_traits<char_type>, this may give surprising +results. + +

      +
      +
      13. + +
    13. +

      +13) Add a footnote after the first sentence of 27.7.4 [ext.manip]/8: +

      + +
      +

      +Returns: An object of unspecified type such that if in is an +object of type basic_istream<charT, traits> then the expression +in >>get_time(tmb, fmt) behaves as if it called f(in, tmb, fmt), +where the function f is defined as:(footnote) [..] +

      + +

      + +footnote) If the traits of the input stream has different semantics for lt(), +eq(), and assign() than char_traits<char_type>, this may give surprising +results. + +

      +
      +
      14. + +
    14. +

      +Add a footnote after the first sentence of 27.7.4 [ext.manip]/10: +

      + +
      +

      +Returns: An object of unspecified type such that if out is an object of type +basic_ostream<charT, traits> then the expression out <<put_time(tmb, fmt) +behaves as if it called f(out, tmb, fmt), where the function f is defined +as:(footnote) [..] +

      + +

      + +footnote) If the traits of the output stream has different semantics for lt(), +eq(), and assign() than char_traits<char_type>, this may give surprising +results. + +

      +
      +
      15. +
    +

    430. valarray subset operations

    -

    Section: 26.6.2.4 [valarray.sub] Status: Ready - Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-07-14

    -

    View all issues with Ready status.

    +

    Section: 26.6.2.4 [valarray.sub] Status: Open + Submitter: Martin Sebor Opened: 2003-09-18 Last modified: 2009-11-04

    +

    View all issues with Open status.

    Discussion:

    The standard fails to specify the behavior of valarray::operator[](slice) @@ -2286,6 +2249,16 @@ Move to Ready.

    +

    [ +2009-11-04 Pete opens: +]

    + + +
    +The resolution to LWG issue 430 has not been applied --- there have been +changes to the underlying text, and the resolution needs to be reworked. +
    +

    Proposed resolution:

    @@ -2425,119 +2398,19 @@ const size_t vi[] = {7, 5, 2, 3, 8};
    -

    431. Swapping containers with unequal allocators

    -

    Section: X [allocator.requirements], 25 [algorithms] Status: Open - Submitter: Matt Austern Opened: 2003-09-20 Last modified: 2009-07-17

    -

    View other active issues in [allocator.requirements].

    -

    View all other issues in [allocator.requirements].

    +

    446. Iterator equality between different containers

    +

    Section: 24.2 [iterator.requirements], 23.2 [container.requirements] Status: Open + Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2009-11-03

    +

    View other active issues in [iterator.requirements].

    +

    View all other issues in [iterator.requirements].

    View all issues with Open status.

    Discussion:

    -

    Clause X [allocator.requirements] paragraph 4 says that implementations - are permitted to supply containers that are unable to cope with - allocator instances and that container implementations may assume - that all instances of an allocator type compare equal. We gave - implementers this latitude as a temporary hack, and eventually we - want to get rid of it. What happens when we're dealing with - allocators that don't compare equal? -

    - -

    In particular: suppose that v1 and v2 are both - objects of type vector<int, my_alloc> and that - v1.get_allocator() != v2.get_allocator(). What happens if - we write v1.swap(v2)? Informally, three possibilities:

    - -

    1. This operation is illegal. Perhaps we could say that an - implementation is required to check and to throw an exception, or - perhaps we could say it's undefined behavior.

    -

    2. The operation performs a slow swap (i.e. using three - invocations of operator=, leaving each allocator with its - original container. This would be an O(N) operation.

    -

    3. The operation swaps both the vectors' contents and their - allocators. This would be an O(1) operation. That is:

    -
    - 
        my_alloc a1(...);
-    my_alloc a2(...);
-    assert(a1 != a2);
-
-    vector<int, my_alloc> v1(a1);
-    vector<int, my_alloc> v2(a2);
-    assert(a1 == v1.get_allocator());
-    assert(a2 == v2.get_allocator());
-
-    v1.swap(v2);
-    assert(a1 == v2.get_allocator());
-    assert(a2 == v1.get_allocator());
-
    -
    - -

    [Kona: This is part of a general problem. We need a paper - saying how to deal with unequal allocators in general.]

    - - -

    [pre-Sydney: Howard argues for option 3 in -N1599. -]

    - - -

    [ -2007-01-12, Howard: This issue will now tend to come up more often with move constructors -and move assignment operators. For containers, these members transfer resources (i.e. -the allocated memory) just like swap. -]

    - - -

    [ -Batavia: There is agreement to overload the container swap on the allocator's Swappable -requirement using concepts. If the allocator supports Swappable, then container's swap will -swap allocators, else it will perform a "slow swap" using copy construction and copy assignment. -]

    - - -

    [ -2009-04-28 Pablo adds: -]

    - -
    -Fixed in -N2525. -I argued for marking this Tentatively-Ready right after Bellevue, -but there was a concern that -N2525 -would break in the presence of the RVO. (That breakage had nothing to do with -swap, but never-the-less). I addressed that breakage in in -N2840 -(Summit) by means of a non-normative reference: - -
    -[Note: in situations where the copy constructor for a container is elided, -this function is not called. The behavior in these cases is as if -select_on_container_copy_construction returned x — end note] -
    - -
    - - - -

    Proposed resolution:

    - - - - - -
    -

    446. Iterator equality between different containers

    -

    Section: 24.2 [iterator.concepts], 23.2 [container.requirements] Status: Open - Submitter: Andy Koenig Opened: 2003-12-16 Last modified: 2009-07-14

    -

    View other active issues in [iterator.concepts].

    -

    View all other issues in [iterator.concepts].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    -What requirements does the standard place on equality comparisons between -iterators that refer to elements of different containers. For example, if -v1 and v2 are empty vectors, is v1.end() == v2.end() allowed to yield true? -Is it allowed to throw an exception? -

    +

    +What requirements does the standard place on equality comparisons between +iterators that refer to elements of different containers. For example, if +v1 and v2 are empty vectors, is v1.end() == v2.end() allowed to yield true? +Is it allowed to throw an exception? +

    The standard appears to be silent on both questions. @@ -2562,97 +2435,42 @@ reachability. Daniel volunteered to work on this. - - -

    Proposed resolution:

    - - - - - - -
    -

    458. 24.1.5 contains unintended limitation for operator-

    -

    Section: 24.2.6 [random.access.iterators] Status: Open - Submitter: Daniel Frey Opened: 2004-02-27 Last modified: 2009-07-17

    -

    View other active issues in [random.access.iterators].

    -

    View all other issues in [random.access.iterators].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    -In 24.1.5 [lib.random.access.iterators], table 76 the operational -semantics for the expression "r -= n" are defined as "return r += -n". -This means, that the expression -n must be valid, which is not the case -for unsigned types. -

    -

    [ -Sydney: Possibly not a real problem, since difference type is required -to be a signed integer type. However, the wording in the standard may -be less clear than we would like. +2009-09-20 Daniel provided wording. ]

    [ -Post Summit Alisdair adds: +2009-10 Santa Cruz: ]

    -

    -This issue refers to a requirements table we have removed. -

    -

    -The issue might now relate to 24.2.6 [random.access.iterators] p5. -However, the rationale in the issue already recognises that the -difference_type must be signed, so this really looks NAD. -

    +Leave as Open. Alisdair has volunteered to refine the wording.
    -

    [ -Batavia (2009-05): -]

    -
    -

    -We agree with Alisdair's observations. -

    + +

    Proposed resolution:

    -Move to NAD. +Insert a new paragraph between 24.2 [iterator.requirements]/7+8:

    -
    - -

    [ -2009-07 Frankfurt: -]

    -

    -Need to look at again without concepts. -

    -

    -There was a question about this phrase in the discussion: "the -expression -n must be valid, which is not the case for unsigned types." -If n is an object ofthe iterator difference_type (eg ptrdiff_t), then it -is never unsigned. +[..] The result of the application of functions in the library to invalid +ranges is undefined.

    -
    - - -

    Proposed resolution:

    -

    -To remove this limitation, I suggest to change the -operational semantics for this column to: +

    The result of directly or indirectly evaluating any comparison function +or the binary - operator with two iterator values as arguments that +were obtained +from two different ranges r1 and r2 (including their past-the-end values) which +are not subranges of one common range is undefined, unless explicitly +described otherwise.

    -
        { Distance m = n;
-      if (m >= 0)
-        while (m--) --r;
-      else
-        while (m++) ++r;
-      return r; }
-
    + + @@ -2660,573 +2478,212 @@ operational semantics for this column to:
    -

    463. auto_ptr usability issues

    -

    Section: D.9.1 [auto.ptr] Status: Open - Submitter: Rani Sharoni Opened: 2003-12-07 Last modified: 2009-07-14

    -

    View all other issues in [auto.ptr].

    -

    View all issues with Open status.

    +

    471. result of what() implementation-defined

    +

    Section: 18.8.1 [exception] Status: Ready + Submitter: Martin Sebor Opened: 2004-06-28 Last modified: 2009-10-26

    +

    View all issues with Ready status.

    Discussion:

    -

    -TC1 CWG DR #84 effectively made the template<class Y> operator auto_ptr<Y>() -member of auto_ptr (20.4.5.3/4) obsolete. -

    - -

    -The sole purpose of this obsolete conversion member is to enable copy -initialization base from r-value derived (or any convertible types like -cv-types) case: -

    -
    #include <memory>
-using std::auto_ptr;
-
-struct B {};
-struct D : B {};
-
-auto_ptr<D> source();
-int sink(auto_ptr<B>);
-int x1 = sink( source() ); // #1 EDG - no suitable copy constructor
-
    - -

    -The excellent analysis of conversion operations that was given in the final -auto_ptr proposal -(http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf) -explicitly specifies this case analysis (case 4). DR #84 makes the analysis -wrong and actually comes to forbid the loophole that was exploited by the -auto_ptr designers. -

    - -

    -I didn't encounter any compliant compiler (e.g. EDG, GCC, BCC and VC) that -ever allowed this case. This is probably because it requires 3 user defined -conversions and in fact current compilers conform to DR #84. -

    +

    [lib.exception] specifies the following:

    +
        exception (const exception&) throw();
+    exception& operator= (const exception&) throw();
 
-
    
-I was surprised to discover that the obsolete conversion member actually has
-negative impact of the copy initialization base from l-value derived
-case:
    
-
    auto_ptr<D> dp;
-int x2 = sink(dp); // #2 EDG - more than one user-defined conversion applies
+    -4- Effects: Copies an exception object.
+    -5- Notes: The effects of calling what() after assignment
+        are implementation-defined.
 
    
 
 
    
-I'm sure that the original intention was allowing this initialization using
-the template<class Y> auto_ptr(auto_ptr<Y>& a) constructor (20.4.5.1/4) but
-since in this copy initialization it's merely user defined conversion (UDC)
-and the obsolete conversion member is UDC with the same rank (for the early
-overloading stage) there is an ambiguity between them.
+First, does the Note only apply to the assignment operator? If so,
+what are the effects of calling what() on a copy of an object? Is
+the returned pointer supposed to point to an identical copy of
+the NTBS returned by what() called on the original object or not?
 
    
 
 
    
-Removing the obsolete member will have impact on code that explicitly
-invokes it:
+Second, is this Note intended to extend to all the derived classes
+in section 19? I.e., does the standard provide any guarantee for
+the effects of what() called on a copy of any of the derived class
+described in section 19?
 
    
-
    int y = sink(source().operator auto_ptr<B>());
-
    
 
 
    
-IMHO no one ever wrote such awkward code and the reasonable workaround for
-#1 is:
+Finally, if the answer to the first question is no, I believe it
+constitutes a defect since throwing an exception object typically
+implies invoking the copy ctor on the object. If the answer is yes,
+then I believe the standard ought to be clarified to spell out
+exactly what the effects are on the copy (i.e., after the copy
+ctor was called).
 
    
-
    int y = sink( auto_ptr<B>(source()) );
-
    
 
-
    
-I was even more surprised to find out that after removing the obsolete
-conversion member the initialization was still ill-formed:
-int x3 = sink(dp); // #3 EDG - no suitable copy constructor
-
    
+
    [Redmond: Yes, this is fuzzy.  The issue of derived classes is
+  fuzzy too.]
    
 
-
    
-This copy initialization semantically requires copy constructor which means
-that both template conversion constructor and the auto_ptr_ref conversion
-member (20.4.5.3/3) are required which is what was explicitly forbidden in
-DR #84. This is a bit amusing case in which removing ambiguity results with
-no candidates.
-
    
 
-
    
-I also found exception safety issue with auto_ptr related to auto_ptr_ref:
-
    
-
    int f(auto_ptr<B>, std::string);
-auto_ptr<B> source2();
+
    [
+Batavia: Howard provided wording.
+]
    
 
-// string constructor throws while auto_ptr_ref
-// "holds" the pointer
-int x4 = f(source2(), "xyz"); // #4
-
    
 
-
    
-The theoretic execution sequence that will cause a leak:
-
    
-
      
-
    1. call auto_ptr<B>::operator auto_ptr_ref<B>()
      2. 
-
    2. call string::string(char const*) and throw
      3. 
-
    
+
    [
+Bellevue:
+]
    
 
-
    
-According to 20.4.5.3/3 and 20.4.5/2 the auto_ptr_ref conversion member
-returns auto_ptr_ref<Y> that holds *this and this is another defect since
-the type of *this is auto_ptr<X> where X might be different from Y. Several
-library vendors (e.g. SGI) implement auto_ptr_ref<Y> with Y* as member which
-is much more reasonable. Other vendor implemented auto_ptr_ref as
-defectively required and it results with awkward and catastrophic code:
-int oops = sink(auto_ptr<B>(source())); // warning recursive on all control
-paths
-
    
 
+
    
 
    
-Dave Abrahams noticed that there is no specification saying that
-auto_ptr_ref copy constructor can't throw.
+Eric concerned this is unimplementable, due to nothrow guarantees.
+Suggested implementation would involve reference counting.
 
    
-
 
    
-My proposal comes to solve all the above issues and significantly simplify
-auto_ptr implementation. One of the fundamental requirements from auto_ptr
-is that it can be constructed in an intuitive manner (i.e. like ordinary
-pointers) but with strict ownership semantics which yield that source
-auto_ptr in initialization must be non-const. My idea is to add additional
-constructor template with sole propose to generate ill-formed, diagnostic
-required, instance for const auto_ptr arguments during instantiation of
-declaration. This special constructor will not be instantiated for other
-types which is achievable using 14.8.2/2 (SFINAE). Having this constructor
-in hand makes the constructor template<class Y> auto_ptr(auto_ptr<Y> const&)
-legitimate since the actual argument can't be const yet non const r-value
-are acceptable.
+Is the implied reference counting subtle enough to call out a note on
+implementation? Probably not.
 
    
-
 
    
-This implementation technique makes the "private auxiliary class"
-auto_ptr_ref obsolete and I found out that modern C++ compilers (e.g. EDG,
-GCC and VC) consume the new implementation as expected and allow all
-intuitive initialization and assignment cases while rejecting illegal cases
-that involve const auto_ptr arguments.
+If reference counting required, could we tighten specification further
+to require same pointer value? Probably an overspecification, especially
+if exception classes defer evalutation of final string to calls to
+what().
 
    
-
-
    The proposed auto_ptr interface:
    
-
-
    namespace std {
-    template<class X> class auto_ptr {
-    public:
-        typedef X element_type;
-
-        // 20.4.5.1 construct/copy/destroy:
-        explicit auto_ptr(X* p=0) throw();
-        auto_ptr(auto_ptr&) throw();
-        template<class Y> auto_ptr(auto_ptr<Y> const&) throw();
-        auto_ptr& operator=(auto_ptr&) throw();
-        template<class Y> auto_ptr& operator=(auto_ptr<Y>) throw();
-        ~auto_ptr() throw();
-
-        // 20.4.5.2 members:
-        X& operator*() const throw();
-        X* operator->() const throw();
-        X* get() const throw();
-        X* release() throw();
-        void reset(X* p=0) throw();
-
-    private:
-        template<class U>
-        auto_ptr(U& rhs, typename
-unspecified_error_on_const_auto_ptr<U>::type = 0);
-    };
-}
-
    
-
 
    
-One compliant technique to implement the unspecified_error_on_const_auto_ptr
-helper class is using additional private auto_ptr member class template like
-the following:
+Remember issue moved open and not resolved at Batavia, but cannot
+remember who objected to canvas a disenting opinion - please speak up if
+you disagree while reading these minutes!
 
    
-
    template<typename T> struct unspecified_error_on_const_auto_ptr;
-
-template<typename T>
-struct unspecified_error_on_const_auto_ptr<auto_ptr<T> const>
-{ typedef typename auto_ptr<T>::const_auto_ptr_is_not_allowed type; };
-
    
-
 
    
-There are other techniques to implement this helper class that might work
-better for different compliers (i.e. better diagnostics) and therefore I
-suggest defining its semantic behavior without mandating any specific
-implementation. IMO, and I didn't found any compiler that thinks otherwise,
-14.7.1/5 doesn't theoretically defeat the suggested technique but I suggest
-verifying this with core language experts.
+Move to Ready as we are accepting words unmodified.
 
    
+
    
 
-
    Further changes in standard text:
    
-
    Remove section 20.4.5.3
    
-
-
    Change 20.4.5/2 to read something like:
-Initializing auto_ptr<X> from const auto_ptr<Y> will result with unspecified
-ill-formed declaration that will require unspecified diagnostic.
    
-
-
    Change 20.4.5.1/4,5,6 to read:
    
-
-
    template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();
    
-
     4 Requires: Y* can be implicitly converted to X*.
    
-
     5 Effects: Calls const_cast<auto_ptr<Y>&>(a).release().
    
-
     6 Postconditions: *this holds the pointer returned from a.release().
    
+
    [
+Sophia Antipolis:
+]
    
 
-
    Change 20.4.5.1/10
    
-
    template<class Y> auto_ptr& operator=(auto_ptr<Y> a) throw();
-
    
-
    
-10 Requires: Y* can be implicitly converted to X*. The expression delete
-get() is well formed.
-
    
 
-
    LWG TC DR #127 is obsolete.
    
+
    
+The issue was pulled from Ready.  It needs to make clear that only homogenous copying
+is intended to be supported, not coping from a derived to a base.
+
    
 
-
    
-Notice that the copy constructor and copy assignment operator should remain
-as before and accept non-const auto_ptr& since they have effect on the form
-of the implicitly declared copy constructor and copy assignment operator of
-class that contains auto_ptr as member per 12.8/5,10:
-
    
-
    struct X {
-    // implicit X(X&)
-    // implicit X& operator=(X&)
-    auto_ptr<D> aptr_;
-};
-
    
+
    [
+Batavia (2009-05):
+]
    
 
+
    
 
    
-In most cases this indicates about sloppy programming but preserves the
-current auto_ptr behavior.
+Howard supplied the following replacement wording
+for paragraph 7 of the proposed resolution:
 
    
-
+
    
+-7- Postcondition: what() shall return the same NTBS
+  as would be obtained by using static_cast
+  to cast the rhs to the same types as the lhs
+  and then calling what() on that possibly sliced object.
+
    
 
    
-Dave Abrahams encouraged me to suggest fallback implementation in case that
-my suggestion that involves removing of auto_ptr_ref will not be accepted.
-In this case removing the obsolete conversion member to auto_ptr<Y> and
-20.4.5.3/4,5 is still required in order to eliminate ambiguity in legal
-cases. The two constructors that I suggested will co exist with the current
-members but will make auto_ptr_ref obsolete in initialization contexts.
-auto_ptr_ref will be effective in assignment contexts as suggested in DR
-#127 and I can't see any serious exception safety issues in those cases
-(although it's possible to synthesize such). auto_ptr_ref<X> semantics will
-have to be revised to say that it strictly holds pointer of type X and not
-reference to an auto_ptr for the favor of cases in which auto_ptr_ref<Y> is
-constructed from auto_ptr<X> in which X is different from Y (i.e. assignment
-from r-value derived to base).
+Pete asks what "the same NTBS" means.
 
    
-
-
    [Redmond: punt for the moment. We haven't decided yet whether we
-  want to fix auto_ptr for C++-0x, or remove it and replace it with
-  move_ptr and unique_ptr.]
    
-
+
    
 
 
    [
-Oxford 2007: Recommend NAD.  We're just going to deprecate it.  It still works for simple use cases
-and people know how to deal with it.  Going forward unique_ptr is the recommended
-tool.
+2009-07-30 Niels adds:
 ]
    
 
 
-
    [
-2007-11-09: Reopened at the request of David Abrahams, Alisdair Meredith and Gabriel Dos Reis.
-]
    
-
+
    
+Further discussion in the thread starting with c++std-lib-24512.
+
    
 
 
    [
-2009-07 Frankfurt
+2009-09-24 Niels provided updated wording:
 ]
    
 
 
 
    
-This is a complicated issue, so we agreed to defer discussion until
-later in the week so that interested parties can read up on it.
-
    
-
-
-
-
    Proposed resolution:
    
 
    
-Change the synopsis in D.9.1 [auto.ptr]:
+I think the resolution should at least guarantee
+that the result of what() is independent of whether the compiler does
+copy-elision. And for any class derived from std::excepion that has a
+constructor that allows specifying a what_arg, it should make sure that
+the text of a user-provided what_arg is preserved, when the object is
+copied. Note that all the implementations I've tested already appear to
+satisfy the proposed resolution, including MSVC 2008 SP1, Apache
+stdcxx-4.2.1, GCC 4.1.2, GCC 4.3.2, and CodeGear C++ 6.13.
 
    
+
    
+The proposed resolution was updated with help from Daniel Krügler;
+the update aims to clarify that the proposed postcondition only
+applies to homogeneous copying.
+
    
+
 
-
    namespace std { 
-  template <class Y> struct auto_ptr_ref {};
-
-  // exposition only
-  template <class T> struct constant_object;
-
-  // exposition only
-  template <class T>
-  struct cannot_transfer_ownership_from
-    : constant_object<T> {};
-
-  template <class X> class auto_ptr { 
-  public: 
-    typedef X element_type; 
-
-    // D.9.1.1 construct/copy/destroy: 
-    explicit auto_ptr(X* p =0) throw(); 
-    auto_ptr(auto_ptr&) throw(); 
-    template<class Y> auto_ptr(auto_ptr<Y> const&) throw(); 
-    auto_ptr& operator=(auto_ptr&) throw(); 
-    template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
-    auto_ptr& operator=(auto_ptr_ref<X> r) throw();
-    ~auto_ptr() throw(); 
+
    [
+2009-10 Santa Cruz:
+]
    
 
-    // D.9.1.2 members: 
-    X& operator*() const throw();
-    X* operator->() const throw();
-    X* get() const throw();
-    X* release() throw();
-    void reset(X* p =0) throw();
 
-    // D.9.1.3 conversions:
-    auto_ptr(auto_ptr_ref<X>) throw();
-    template<class Y> operator auto_ptr_ref<Y>() throw();
-    template<class Y> operator auto_ptr<Y>() throw();
+
    
+Moved to Ready after inserting "publicly accessible" in two places.
+
    
 
-    // exposition only
-    template<class U>
-    auto_ptr(U& rhs, typename cannot_transfer_ownership_from<U>::error = 0);
-  }; 
 
-  template <> class auto_ptr<void> 
-  { 
-  public: 
-    typedef void element_type; 
-  }; 
 
-}
-
    
+
    Proposed resolution:
    
 
 
    
-Remove D.9.1.3 [auto.ptr.conv].
+Change 18.8.1 [exception] to:
 
    
 
+
    
 
    
-Change D.9.1 [auto.ptr], p3:
+-1- The class exception defines the base class for the types of
+objects thrown as exceptions by C++ standard library components, and
+certain expressions, to report errors detected during program execution.
 
    
-
-
    
-The auto_ptr provides a semantics of strict ownership. An
-auto_ptr owns the object it holds a pointer to. Copying an
-auto_ptr copies the pointer and transfers ownership to the
-destination. If more than one auto_ptr owns the same object at
-the same time the behavior of the program is undefined. Templates
-constant_object and cannot_transfer_ownership_from,
-and the final constructor of auto_ptr are for exposition only.
-For any types X and Y, initializing
-auto_ptr<X> from const auto_ptr<Y> is
-ill-formed, diagnostic required. [Note: The uses of
-auto_ptr include providing temporary exception-safety for
-dynamically allocated memory, passing ownership of dynamically allocated
-memory to a function, and returning dynamically allocated memory from a
-function. auto_ptr does not meet the CopyConstructible
-and Assignable requirements for Standard Library container
-elements and thus instantiating a Standard Library container with an
-auto_ptr results in undefined behavior. -- end note]
-
    
-
+
    
+Each standard library class T that derives from class
+exception shall have a publicly accessible copy constructor and a publicly accessible copy assignment
+operator that do not exit with an exception. These member functions
+shall preserve the following postcondition: If two objects lhs
+and rhs both have dynamic type T, and lhs is a
+copy of rhs, then strcmp(lhs.what(),
+rhs.what()) == 0.
+
    
 
    
-Change D.9.1.1 [auto.ptr.cons], p5:
+ ...
 
    
 
-
    
-
    template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();
-
    
+
    exception(const exception& rhs) throw();
+exception& operator=(const exception& rhs) throw();
    
+
 
    
 
    
-Requires: Y* can be implicitly converted to X*.
+-4- Effects: Copies an exception object.
 
    
 
    
-Effects: Calls const_cast<auto_ptr<Y>&>(a).release().
+ -5- Remarks: The effects of calling what() after assignment
+are implementation-defined.
 
    
 
    
-Postconditions: *this holds the pointer returned from a.release().
+-5- Postcondition:
+	If *this
+	and rhs both have dynamic type exception
+	then strcmp(what(), rhs.what()) == 0.
 
    
+
 
    
+
 
    
 
-
    
-Change D.9.1.1 [auto.ptr.cons], p10:
-
    
-
-
    
-
    template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();
-
    
-
    
-
    
-Requires: Y* can be implicitly converted to X*.
-The expression delete get() is well formed.
-
    
-
    
-Effects: Calls reset(a.release()).
-
    
-
    
-Returns: *this.
-
    
-
    
-
    
-
-
-
-
-
-
-
    
-
    471. result of what() implementation-defined
    
-
    Section: 18.8.1 [exception] Status: Open
- Submitter: Martin Sebor Opened: 2004-06-28  Last modified: 2009-07-30
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    [lib.exception] specifies the following:
    
-
        exception (const exception&) throw();
-    exception& operator= (const exception&) throw();
-
-    -4- Effects: Copies an exception object.
-    -5- Notes: The effects of calling what() after assignment
-        are implementation-defined.
-
    
-
-
    
-First, does the Note only apply to the assignment operator? If so,
-what are the effects of calling what() on a copy of an object? Is
-the returned pointer supposed to point to an identical copy of
-the NTBS returned by what() called on the original object or not?
-
    
-
-
    
-Second, is this Note intended to extend to all the derived classes
-in section 19? I.e., does the standard provide any guarantee for
-the effects of what() called on a copy of any of the derived class
-described in section 19?
-
    
-
-
    
-Finally, if the answer to the first question is no, I believe it
-constitutes a defect since throwing an exception object typically
-implies invoking the copy ctor on the object. If the answer is yes,
-then I believe the standard ought to be clarified to spell out
-exactly what the effects are on the copy (i.e., after the copy
-ctor was called).
-
    
-
-
    [Redmond: Yes, this is fuzzy.  The issue of derived classes is
-  fuzzy too.]
    
-
-
-
    [
-Batavia: Howard provided wording.
-]
    
-
-
-
    [
-Bellevue:
-]
    
-
-
-
    
-
    
-Eric concerned this is unimplementable, due to nothrow guarantees.
-Suggested implementation would involve reference counting.
-
    
-
    
-Is the implied reference counting subtle enough to call out a note on
-implementation? Probably not.
-
    
-
    
-If reference counting required, could we tighten specification further
-to require same pointer value? Probably an overspecification, especially
-if exception classes defer evalutation of final string to calls to
-what().
-
    
-
    
-Remember issue moved open and not resolved at Batavia, but cannot
-remember who objected to canvas a disenting opinion - please speak up if
-you disagree while reading these minutes!
-
    
-
    
-Move to Ready as we are accepting words unmodified.
-
    
-
    
-
-
    [
-Sophia Antipolis:
-]
    
-
-
-
    
-The issue was pulled from Ready.  It needs to make clear that only homogenous copying
-is intended to be supported, not coping from a derived to a base.
-
    
-
-
    [
-Batavia (2009-05):
-]
    
-
-
    
-
    
-Howard supplied the following replacement wording
-for paragraph 7 of the proposed resolution:
-
    
-
    
--7- Postcondition: what() shall return the same NTBS
-  as would be obtained by using static_cast
-  to cast the rhs to the same types as the lhs
-  and then calling what() on that possibly sliced object.
-
    
-
    
-Pete asks what "the same NTBS" means.
-
    
-
    
-
-
    [
-2009-07-30 Niels adds:
-]
    
-
-
-
    
-Further discussion in the thread starting with c++std-lib-24512.
-
    
-
-
-
-
    Proposed resolution:
    
-
-
    
-Change 18.8.1 [exception] to:
-
    
-
-
    
-
    exception(const exception& e) throw();
-exception& operator=(const exception& e) throw();
    
-
    
-
    
--4- Effects: Copies an exception object.
-
    
-
    
- -5- Remarks: The effects of calling what() after assignment are implementation-defined.
-
    
-
    
--5- Throws: Nothing.  This also applies
-to all standard library-defined classes that derive from exception.
-
    
-
    
--7- Postcondition: strcmp(what(), e.what()) == 0.  This also applies
-to all standard library-defined classes that derive from exception.
-
    
-
-
    
-
    
 
 
 
 
 
    
 
    473. underspecified ctype calls
    
-
    Section: 22.4.1.1 [locale.ctype] Status: Review
- Submitter: Martin Sebor Opened: 2004-07-01  Last modified: 2009-07-17
    
-
    View all issues with Review status.
    
+
    Section: 22.4.1.1 [locale.ctype] Status: Ready
+ Submitter: Martin Sebor Opened: 2004-07-01  Last modified: 2009-10-21
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
 Most ctype member functions come in two forms: one that operates
@@ -3305,6 +2762,15 @@ provide wording.
    
 ]
    
 
 
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
 
 
 
    Proposed resolution:
    
@@ -3319,91 +2785,22 @@ virtual function.
 
 
 
-
-
-
    
-
    484. Convertible to T
    
-
    Section: 24.2.2 [input.iterators] Status: Open
- Submitter: Chris Jefferson Opened: 2004-09-16  Last modified: 2009-07-28
    
-
    View all other issues in [input.iterators].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    From comp.std.c++:
    
-
+
    Rationale:
    
 
    
-I note that given an input iterator a for type T, 
-then *a only has to be "convertable to T", not actually of type T.
+We are explicitly not addressing bullet
+item #2, thus giving implementors more latitude. Users will have to
+override both virtual functions, not just one.
 
    
 
-
    Firstly, I can't seem to find an exact definition of "convertable to T". 
-While I assume it is the obvious definition (an implicit conversion), I 
-can't find an exact definition. Is there one?
    
-
-
    Slightly more worryingly, there doesn't seem to be any restriction on 
-the this type, other than it is "convertable to T". Consider two input 
-iterators a and b. I would personally assume that most people would 
-expect *a==*b would perform T(*a)==T(*b), however it doesn't seem that 
-the standard requires that, and that whatever type *a is (call it U) 
-could have == defined on it with totally different symantics and still 
-be a valid inputer iterator.
    
-
-
    Is this a correct reading? When using input iterators should I write 
-T(*a) all over the place to be sure that the object i'm using is the 
-class I expect?
    
-
-
    This is especially a nuisance for operations that are defined to be
-  "convertible to bool".  (This is probably allowed so that
-  implementations could return say an int and avoid an unnessary
-  conversion. However all implementations I have seen simply return a
-  bool anyway.  Typical implemtations of STL algorithms just write
-  things like while(a!=b && *a!=0).  But strictly
-  speaking, there are lots of types that are convertible to T but
-  that also overload the appropriate operators so this doesn't behave
-  as expected.
    
-
-
    If we want to make code like this legal (which most people seem to
-  expect), then we'll need to tighten up what we mean by "convertible
-  to T".
    
-
-
    [Lillehammer: The first part is NAD, since "convertible" is
- well-defined in core. The second part is basically about pathological
- overloads. It's a minor problem but a real one. So leave open for
- now, hope we solve it as part of iterator redesign.]
    
-
-
-
    [
-2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
-]
    
-
-
-
-
-
    Proposed resolution:
    
-
-
-
    Rationale:
    
-
    [
-San Francisco:
-]
    
-
-
-
    
-Solved by
-N2758.
-
    
-
-
-
-
 
 
 
 
    
 
    485. output iterator insufficiently constrained
    
-
    Section: 24.2.3 [output.iterators] Status: Open
- Submitter: Chris Jefferson Opened: 2004-10-13  Last modified: 2009-07-21
    
+
    Section: 24.2.2 [output.iterators] Status: Ready
+ Submitter: Chris Jefferson Opened: 2004-10-13  Last modified: 2009-10-26
    
 
    View all other issues in [output.iterators].
    
-
    View all issues with Open status.
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
 The note on 24.1.2 Output iterators insufficiently limits what can be
@@ -3446,16 +2843,34 @@ Bill provided wording according to consensus.
 
    
 
 
    [
-2009-07-21 Alsidair requests change from Review to Open.  See thread starting
+2009-07-21 Alisdair requests change from Review to Open.  See thread starting
 with c++std-lib-24459 for discussion.
 ]
    
 
 
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Modified wording.  Set to Review.
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Move to Ready after looking at again in a larger group in Santa Cruz.
+
    
+
 
 
 
    Proposed resolution:
    
 
    
-Change Table 101 — Output iterator requirements in 24.2.3 [output.iterators]:
+Change Table 101 — Output iterator requirements in 24.2.2 [output.iterators]:
 
    
 
    
 
@@ -3499,62 +2914,69 @@ Change Table 101 — Output iterator requirements in 24.2.3 [output.iterator
 
-
-
+
+
-
-
+
+
-
+
+Post: r is dereferenceable, unless otherwise specified.  r is not required to be incrementable.
+
+
-
-
+
-
+
+
 
@@ -3566,258 +2988,20 @@ result is not usedusable
    
-
    498. Requirements for partition() and stable_partition() too strong
    
-
    Section: 25.4.13 [alg.partitions] Status: Ready
- Submitter: Sean Parent, Joe Gottman Opened: 2005-05-04  Last modified: 2009-07-15
    
+
    539. partial_sum and adjacent_difference should mention requirements
    
+
    Section: 26.7.3 [partial.sum] Status: Ready
+ Submitter: Marc Schoolderman Opened: 2006-02-06  Last modified: 2009-10-24
    View all issues with Ready status.
    Discussion:
    
-Problem:
-The iterator requirements for partition() and stable_partition() [25.2.12]
-are listed as BidirectionalIterator, however, there are efficient algorithms
-for these functions that only require ForwardIterator that have been known
-since before the standard existed. The SGI implementation includes these (see
-http://www.sgi.com/tech/stl/partition.html
-and
-http://www.sgi.com/tech/stl/stable_partition.html).
+There are some problems in the definition of partial_sum and
+adjacent_difference in 26.4 [lib.numeric.ops]
 
    
 
-
    [
-2009-04-30 Alisdair adds:
-]
    
-
-
-
    
-
    
-Now we have concepts this is easier to express!
-
    
-
    
-Proposed resolution:
-
    
 
    
-Add the following signature to:
-
    
-
    
-Header <algorithm> synopsis 25.2 [algorithms.syn]
    
-p3 Partitions 25.4.13 [alg.partitions]
-
    
-
     template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred>
-   requires ShuffleIterator<Iter>
-         && CopyConstructible<Pred>
-   Iter partition(Iter first, Iter last, Pred pred);
-
    
-
-
    
-Update p3 Partitions 25.4.13 [alg.partitions]:
-
    
-
-
    
-
    
-Complexity: At most (last - first)/2 swaps. Exactly last - first
-applications of the predicate
-are done.
-
-If Iter satisfies BidirectionalIterator, at most (last -
-first)/2 swaps. Exactly last - first applications of the predicate
-are done.
-
-
    
-
    
-If Iter merely satisfied ForwardIterator at most (last - first) swaps
-are done. Exactly (last - first) applications of the predicate are done.
-
    
-
    
-
-
    
-[Editorial note: I looked for existing precedent in how we might call out
-distinct overloads overloads from a set of constrained templates, but there
-is not much existing practice to lean on.   advance/distance were the only
-algorithms I could find, and that wording is no clearer.]
-
    
-
-
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-
    
-Hinnant: if you want to partition your std::forward_list, you'll need
-partition() to accept ForwardIterators.
-
    
-
    
-No objection to Ready.
-
    
-
    
-Move to Ready.
-
    
-
    
-
-
-
-
    Proposed resolution:
    
-
    
-Change 25.2.12 from 
    
-
    template<class BidirectionalIterator, class Predicate> 
-BidirectionalIterator partition(BidirectionalIterato r first, 
-                                BidirectionalIterator last, 
-                                Predicate pred); 
-
    
-
    to 
    
-
    template<class ForwardIterator, class Predicate> 
-ForwardIterator partition(ForwardIterator first, 
-                          ForwardIterator last, 
-                          Predicate pred); 
-
    
-
    Change the complexity from 
    
-
-
    
-At most (last - first)/2 swaps are done. Exactly (last - first) 
-applications of the predicate are done. 
-
    
-
-
    to 
    
-
-
    
-If ForwardIterator is a bidirectional_iterator, at most (last - first)/2 
-swaps are done; otherwise at most (last - first) swaps are done. Exactly 
-(last - first) applications of the predicate are done. 
-
    
-
-
-
-
    Rationale:
    
-
    
-Partition is a "foundation" algorithm useful in many contexts (like sorting
-as just one example) - my motivation for extending it to include forward
-iterators is foward_list - without this extension you can't partition an foward_list
-(without writing your own partition). Holes like this in the standard
-library weaken the argument for generic programming (ideally I'd be able
-to provide a library that would refine std::partition() to other concepts
-without fear of conflicting with other libraries doing the same - but
-that is a digression). I consider the fact that partition isn't defined
-to work for ForwardIterator a minor embarrassment.
-
    
-
-
    [Mont Tremblant: Moved to Open, request motivation and use cases
-by next meeting. Sean provided further rationale by post-meeting
-mailing.]
    
-
-
-
-
-
-
-
-
    
-
    532. Tuple comparison
    
-
    Section: 20.5.2.5 [tuple.rel], TR1 6.1.3.5 [tr.tuple.rel] Status: Open
- Submitter: David Abrahams Opened: 2005-11-29  Last modified: 2009-07-28
    
-
    View all other issues in [tuple.rel].
    
-
    View all issues with Open status.
    
-
    Duplicate of: 348
    
-
    Discussion:
    
-
    
-Where possible, tuple comparison operators <,<=,=>, and > ought to be
-defined in terms of std::less rather than operator<, in order to
-support comparison of tuples of pointers.  
-
    
-
-
    [
-2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
-]
    
-
-
-
-
-
    Proposed resolution:
    
-
    
-change 6.1.3.5/5 from:
-
    
-
-
    
-  Returns: The result of a lexicographical comparison between t and
-  u. The result is defined as: (bool)(get<0>(t) < get<0>(u)) ||
-  (!(bool)(get<0>(u) < get<0>(t)) && ttail < utail), where rtail for
-  some tuple r is a tuple containing all but the first element of
-  r. For any two zero-length tuples e and f, e < f returns false.
-
    
-
-
    
-to:
-
    
-
-
    
-
    
-  Returns: The result of a lexicographical comparison between t and
-  u. For any two zero-length tuples e and f, e < f returns false.
-  Otherwise, the result is defined as: cmp( get<0>(t), get<0>(u)) ||
-  (!cmp(get<0>(u), get<0>(t)) && ttail < utail), where rtail for some
-  tuple r is a tuple containing all but the first element of r, and
-  cmp(x,y) is an unspecified function template defined as follows.
-
    
-
    
-  Where T is the type of x and U is the type of y:
-
    
-
-
    
-     if T and U are pointer types and T is convertible to U, returns
-     less<U>()(x,y)
-
    
-
-
    
-     otherwise, if T and U are pointer types, returns less<T>()(x,y)
-
    
-
-
    
-     otherwise, returns (bool)(x < y)
-
    
-
    
-
-
    [
-Berlin: This issue is much bigger than just tuple (pair, containers,
-algorithms). Dietmar will survey and work up proposed wording.
-]
    
-
-
-
-
-
    Rationale:
    
-
    
-Recommend NAD.  This will be fixed with the next revision of concepts.
-
    
-
-
    [
-San Francisco:
-]
    
-
-
-
    
-Solved by
-N2770.
-
    
-
-
-
-
-
-
    
-
    539. partial_sum and adjacent_difference should mention requirements
    
-
    Section: 26.7.3 [partial.sum] Status: Open
- Submitter: Marc Schoolderman Opened: 2006-02-06  Last modified: 2009-07-30
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-There are some problems in the definition of partial_sum and
-adjacent_difference in 26.4 [lib.numeric.ops]
-
    
-
-
    
-Unlike accumulate and inner_product, these functions are not
-parametrized on a "type T", instead, 26.4.3 [lib.partial.sum] simply
-specifies the effects clause as;
+Unlike accumulate and inner_product, these functions are not
+parametrized on a "type T", instead, 26.4.3 [lib.partial.sum] simply
+specifies the effects clause as;
 
    
@@ -4020,6 +3204,16 @@ volunteered to correct the wording.
 ]
    
 
 
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
 
 
    Proposed resolution:
    
 
@@ -4159,10 +3353,10 @@ of binary_opthe binary operation.
 
 
    
 
    556. is Compare a BinaryPredicate?
    
-
    Section: 25.5 [alg.sorting] Status: Open
- Submitter: Martin Sebor Opened: 2006-02-05  Last modified: 2009-07-28
    
+
    Section: 25.4 [alg.sorting] Status: Review
+ Submitter: Martin Sebor Opened: 2006-02-05  Last modified: 2009-10-25
    
 
    View all other issues in [alg.sorting].
    
-
    View all issues with Open status.
    
+
    View all issues with Review status.
    
 
    Discussion:
    
 
    
 In 25, p8 we allow BinaryPredicates to return a type that's convertible
@@ -4192,14 +3386,44 @@ is here:
   argument is less than the second, and false otherwise...
 
    
 
+
    [
+Portland:  Jack to define "convertible to bool" such that short circuiting isn't
+destroyed.
+]
    
+
+
 
    [
 2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
 ]
    
 
 
+
    [
+2009-10 Santa Cruz:
+]
    
 
 
-
    Proposed resolution:
    
+
    
+Move to Review once wording received. Stefanus to send proposed wording.
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Move to Review once wording received. Stefanus to send proposed wording.
+
    
+
+
    [
+2009-10-24 Stefanus supplied wording.
+]
    
+
+
+
    
+Move to Review once wording received. Stefanus to send proposed wording.
+Current proposed wording proposed here:
+
    
 
    
 I think we could fix this by rewording 25.3, p2 to read somthing like:
 
    
@@ -4213,12 +3437,25 @@ if the first argument of the call is less than the second, and
 algorithms assuming an ordering relation. It is assumed that comp
 will not apply any non-constant function through the dereferenced iterator.
 
    
+
    
+
 
 
-
    [
-Portland:  Jack to define "convertible to bool" such that short circuiting isn't
-destroyed.
-]
    
+
+
    Proposed resolution:
    
+
    
+Change 25.4 [alg.sorting] p2:
+
    
+
    
+Compare is used as a function object. The return value of
+the function call operator applied to an object of type Compare, when
+converted to type bool, yields true if the first argument of the
+call which returns true if the first argument
+is less than the second, and false otherwise. Compare
+comp is used throughout for algorithms assuming an ordering
+relation. It is assumed that comp will not apply any
+non-constant function through the dereferenced iterator.
+
    Rationale:
    
@@ -4238,567 +3475,52 @@ Solved by
 
 
 
    
-
    564. stringbuf seekpos underspecified
    
-
    Section: 27.8.1.4 [stringbuf.virtuals] Status: Ready
- Submitter: Martin Sebor Opened: 2006-02-23  Last modified: 2009-07-15
    
-
    View all other issues in [stringbuf.virtuals].
    
-
    View all issues with Ready status.
    
+
    594. Disadvantages of defining Swappable in terms of CopyConstructible and Assignable
    
+
    Section: 20.2.1 [utility.arg.requirements] Status: Open
+ Submitter: Niels Dekker Opened: 2006-11-02  Last modified: 2009-11-08
    
+
    View other active issues in [utility.arg.requirements].
    
+
    View all other issues in [utility.arg.requirements].
    
+
    View all issues with Open status.
    Discussion:
    
-The   effects  of  the   seekpos()  member   function  of
-basic_stringbuf  simply say  that the  function positions
-the  input and/or  output  sequences  but fail  to  spell out  exactly
-how. This is in contrast  to the detail in which seekoff()
-is described.
+It seems undesirable to define the Swappable requirement in terms of
+CopyConstructible and Assignable requirements. And likewise, once the
+MoveConstructible and MoveAssignable requirements (N1860) have made it
+into the Working Draft, it seems undesirable to define the Swappable
+requirement in terms of those requirements. Instead, it appears
+preferable to have the Swappable requirement defined exclusively in
+terms of the existence of an appropriate swap function.
 
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-Move to Ready.
-
    
-
-
-
-
    Proposed resolution:
    
-        
    
-
-Change 27.7.1.3, p13 to read:
-
-        
    
-
    
 
    
--13- Effects: Equivalent to seekoff(off_type(sp), ios_base::beg,
-which). Alters the stream position within the controlled sequences,
-if possible, to correspond to the stream position stored in sp
-(as described below).
+Section 20.1.4 [lib.swappable] of the current Working Draft (N2009)
+says:
 
    
+
    
+The Swappable requirement is met by satisfying one or more of the
+following conditions:
    
 
      
-
    • If (which & ios_base::in) != 0, positions the input sequence.
      • 
-
    • If (which & ios_base::out) != 0, positions the output sequence.
      • 
-
    • If sp is an invalid stream position, or if the function
-positions neither sequence, the positioning operation fails. If sp
-has not been obtained by a previous successful call to one of the positioning
-functions (seekoff, seekpos, tellg, tellp)
-the effect is undefined.
      • 
+
    • 
+T is Swappable if T satisfies the CopyConstructible requirements
+(20.1.3) and the Assignable requirements (23.1);
+
      • 
+
    • 
+T is Swappable if a namespace scope function named swap exists in the
+same namespace as the definition of T, such that the expression
+swap(t,u) is valid and has the semantics described in Table 33.
+
      • 
 
    
 
    
-
-
-
    [
-Kona (2007): A pos_type is a position in a stream by
-definition, so there is no ambiguity as to what it means. Proposed
-Disposition: NAD
-]
    
-
-
-
    [
-Post-Kona Martin adds:
-I'm afraid I disagree
-with the Kona '07 rationale for marking it NAD. The only text
-that describes precisely what it means to position the input
-or output sequence is in seekoff(). The seekpos() Effects
-clause is inadequate in comparison and the proposed resolution
-plugs the hole by specifying seekpos() in terms of seekoff().
-]
    
-
-
-
-
-
-
    
-
    565. xsputn inefficient
    
-
    Section: 27.6.2.4.5 [streambuf.virt.put] Status: Ready
- Submitter: Martin Sebor Opened: 2006-02-23  Last modified: 2009-07-15
    
-
    View all issues with Ready status.
    
-
    Discussion:
    
-        
    
-
-streambuf::xsputn()  is  specified  to  have  the  effect  of
-"writing up to  n characters to the output  sequence as if by
-repeated calls to sputc(c)."
-
-        
    
-        
    
-
-Since  sputc() is required  to call  overflow() when
-(pptr()    ==   epptr())    is   true,    strictly   speaking
-xsputn()  should do  the same.   However, doing  so  would be
-suboptimal in  some interesting cases,  such as in unbuffered  mode or
-when the buffer is basic_stringbuf.
-
-        
    
-        
    
-
-Assuming  calling overflow()  is  not really  intended to  be
-required  and the  wording is  simply  meant to  describe the  general
-effect of appending to the end  of the sequence it would be worthwhile
-to  mention in  xsputn() that  the function  is  not actually
-required to cause a call to overflow().
-
-        
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-Move to Ready.
-
    
-
-
-
-
    Proposed resolution:
    
-        
    
-
-Add the following sentence  to the xsputn() Effects clause in
-27.5.2.4.5, p1 (N1804):
-
-        
    
-        
        
-            
    
--1- Effects: Writes up to n characters to the output
-sequence as if by repeated calls to sputc(c). The characters 
-written are obtained from successive elements of the array whose first element
-is designated by s. Writing stops when either n
-characters have been written or a call to sputc(c) would return
-traits::eof(). It is  uspecified whether the function  calls
-overflow() when (pptr() ==  epptr()) becomes true or whether
-it achieves the same effects by other means.
-            
    
-        
        
-        
    
-
-In addition,  I suggest to  add a footnote  to this function  with the
-same text as Footnote 292 to  make it extra clear that derived classes
-are permitted to override xsputn() for efficiency.
-
-        
    
-
-
-
    [
-Kona (2007): We want to permit a streambuf that streams output directly
-to a device without making calls to sputc or overflow. We believe that
-has always been the intention of the committee. We believe that the
-proposed wording doesn't accomplish that. Proposed Disposition: Open
-]
    
-
-
-
-
-
-
    
-
    580. unused allocator members
    
-
    Section: 23.2.1 [container.requirements.general] Status: Open
- Submitter: Martin Sebor Opened: 2006-06-14  Last modified: 2009-07-15
    
-
    View other active issues in [container.requirements.general].
    
-
    View all other issues in [container.requirements.general].
    
-
    View all issues with Open status.
    
-
    Duplicate of: 479
    
-
    Discussion:
    
-        
    
-
-C++ Standard Library  templates that take an allocator  as an argument
-are    required    to    call    the    allocate()    and
-deallocate()  members of the  allocator object  to obtain
-storage.  However, they do not appear to be required to call any other
-allocator      members      such     as      construct(),
-destroy(),           address(),          and
-max_size().  This makes these allocator members less than
-useful in portable programs.
-
-        
    
-        
    
-
-It's unclear to me whether the absence of the requirement to use these
-allocator  members  is  an  unintentional  omission  or  a  deliberate
-choice. However,  since the functions exist in  the standard allocator
-and  since  they are  required  to  be  provided by  any  user-defined
-allocator I  believe the standard  ought to be clarified  to explictly
-specify  whether programs  should or  should not  be able  to  rely on
-standard containers calling the functions.
-
-        
    
-        
    
-
-I  propose  that all  containers  be required  to  make  use of  these
-functions.
-
-        
    
-
    [
-Batavia:  We support this resolution.  Martin to provide wording.
-]
    
-
-
    [
-pre-Oxford:  Martin provided wording.
-]
    
-
-
-
    [
-2009-04-28 Pablo adds:
-]
    
-
-
-
    
-N2554
-(scoped allocators),
-N2768
-(allocator concepts), and
-N2810
-(allocator defects), address all of these points EXCEPT max_size().
-So, I would add a note to that affect and re-class the defect as belonging
-to section 23.2.1 [container.requirements.general].
-
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-The comment in the description of this issue that this "would be"
-rendered editorial by the adoption of N2257 is confusing. It appears
-that N2257 was never adopted.
-
    
-
-
-
-    
    Proposed resolution:
    
-       
    
-
-Specifically, I propose to change 23.2 [container.requirements],
-p9 as follows:
-
-       
    
-           
    
-
    
--9- Copy constructors  for all container types defined  in this clause
-that   are  parametrized  on   Allocator  copy
-anthe  allocator argument from  their respective
-first parameters.
-
-All other  constructors for  these container types  take an
-const  Allocator&  argument  (20.1.6),  an
-allocator whose value_type is the same as the container's
-value_type.
-
-A copy of this  argument isshall be used for any
-memory  allocation  and  deallocation performed,
-by these  constructors and by all  member functions, during
-the  lifetime  of each  container  object.   Allocation shall  be
-performed  "as  if"  by  calling  the  allocate()  member
-function on  a copy  of the allocator  object of the  appropriate type
-New  Footnote),   and  deallocation  "as   if"  by  calling
-deallocate() on  a copy of  the same allocator  object of
-the corresponding type.
-
-A  copy of  this argument  shall also  be used  to  construct and
-destroy objects whose lifetime  is managed by the container, including
-but not  limited to those of  the container's value_type,
-and  to  obtain  their  address.   All  objects  residing  in  storage
-allocated by a  container's allocator shall be constructed  "as if" by
-calling the construct() member  function on a copy of the
-allocator object of  the appropriate type.  The same  objects shall be
-destroyed "as if"  by calling destroy() on a  copy of the
-same allocator object  of the same type.  The  address of such objects
-shall be obtained "as if" by calling the address() member
-function  on  a  copy  of  the allocator  object  of  the  appropriate
-type.
-
-Finally, a copy  of this argument shall be  used by its container
-object to determine  the maximum number of objects  of the container's
-value_type the container may  store at the same time. The
-container  member function max_size() obtains  this number
-from      the      value      returned      by     a      call      to
-get_allocator().max_size().
-
-In   all  container   types  defined   in  this   clause that  are
-parametrized     on    Allocator,     the    member
-get_allocator()     returns     a     copy     of     the
-Allocator     object     used     to    construct     the
-container.258)
-
    
-
    
-New Footnote: This type  may be different from Allocator:
-it     may    be     derived    from     Allocator    via
-Allocator::rebind<U>::other   for  the  appropriate
-type U.
-
    
-           
    
-       
    
-
-The proposed wording seems cumbersome but I couldn't think of a better
-way   to  describe   the   requirement  that   containers  use   their
-Allocator  to manage  only objects  (regardless  of their
-type)  that  persist  over  their  lifetimes  and  not,  for  example,
-temporaries  created on the  stack. That  is, containers  shouldn't be
-required  to  call  Allocator::construct(Allocator::allocate(1),
-elem)  just to  construct a  temporary copy  of an  element, or
-Allocator::destroy(Allocator::address(temp),     1)    to
-destroy temporaries.
-
-       
    
-
-
-
    [
-Howard: This same paragraph will need some work to accommodate 431.
-]
    
-
-
-
    [
-post Oxford:  This would be rendered NAD Editorial by acceptance of
-N2257.
-]
    
-
-
-
-
-
-
    
-
    588. requirements on zero sized tr1::arrays and other details
    
-
    Section: 23.3.1 [array] Status: Tentatively NAD
- Submitter: Gennaro Prota Opened: 2006-07-18  Last modified: 2009-07-15
    
-
    View other active issues in [array].
    
-
    View all other issues in [array].
    
-
    View all issues with Tentatively NAD status.
    
-
    Discussion:
    
-
    
-The wording used for section 23.2.1 [lib.array] seems to be subtly
-ambiguous about zero sized arrays (N==0). Specifically:
-
    
-
    
-* "An instance of array<T, N> stores N elements of type T, so that
-[...]"
-
    
-
    
-Does this imply that a zero sized array object stores 0 elements, i.e.
-that it cannot store any element of type T? The next point clarifies
-the rationale behind this question, basically how to implement begin()
-and end():
-
    
-
    
-* 23.2.1.5 [lib.array.zero], p2: "In the case that N == 0, begin() ==
-end() == unique value."
-
    
-
    
-What does "unique" mean in this context? Let's consider the following
-possible implementations, all relying on a partial specialization:
-
    
-
    a)
-    template< typename T >
-    class array< T, 0 > {
-    
-        ....
-
-        iterator begin()
-        { return iterator( reinterpret_cast< T * >( this ) ); }
-        ....
-
-    };
-
    
-
    
-This has been used in boost, probably intending that the return value
-had to be unique to the specific array object and that array couldn't
-store any T. Note that, besides relying on a reinterpret_cast, has
-(more than potential) alignment problems.
-
    
-
    b)
-    template< typename T >
-    class array< T, 0 > {
-    
-        T t;
-
-        iterator begin()
-        { return iterator( &t ); }
-        ....
-
-    };
-
    
-
    
-This provides a value which is unique to the object and to the type of
-the array, but requires storing a T. Also, it would allow the user to
-mistakenly provide an initializer list with one element.
-
    
-
    
-A slight variant could be returning *the* null pointer of type T
-
    
-
        return static_cast<T*>(0);
-
    
-
    
-In this case the value would be unique to the type array<T, 0> but not
-to the objects (all objects of type array<T, 0> with the same value
-for T would yield the same pointer value).
-
    
-
    
-Furthermore this is inconsistent with what the standard requires from
-allocation functions (see library issue 9).
-
    
-
    
-c) same as above but with t being a static data member; again, the
-value would be unique to the type, not to the object.
-
    
-
    
-d) to avoid storing a T *directly* while disallowing the possibility
-to use a one-element initializer list a non-aggregate nested class
-could be defined
-
    
-
        struct holder { holder() {} T t; } h;
-
    
-
    
-and then begin be defined as
-
    
-
     iterator begin() { return &h.t; }
-
    
-
    
-But then, it's arguable whether the array stores a T or not.
-Indirectly it does.
-
    
-
    
------------------------------------------------------
-
    
-
    
-Now, on different issues:
-
    
-
    
-* what's the effect of calling assign(T&) on a zero-sized array? There
-seems to be only mention of front() and back(), in 23.2.1 [lib.array]
-p4 (I would also suggest to move that bullet to section 23.2.1.5
-[lib.array.zero], for locality of reference)
-
    
-
    
-* (minor) the opening paragraph of 23.2.1 [lib.array] wording is a bit
-inconsistent with that of other sequences: that's not a problem in
-itself, but compare it for instance with "A vector is a kind of
-sequence that supports random access iterators"; though the intent is
-obvious one might argue that the wording used for arrays doesn't tell
-what an array is, and relies on the reader to infer that it is what
-the <array> header defines.
-
    
-
    
-* it would be desiderable to have a static const data member of type
-std::size_t, with value N, for usage as integral constant expression
-
    
-
    
-* section 23.1 [lib.container.requirements] seem not to consider
-fixed-size containers at all, as it says: "[containers] control
-allocation and deallocation of these objects [the contained objects]
-through constructors, destructors, *insert and erase* operations"
-
    
-
    
-* max_size() isn't specified: the result is obvious but, technically,
-it relies on table 80: "size() of the largest possible container"
-which, again, doesn't seem to consider fixed size containers
-
    
-
-
    [
-2009-05-29 Daniel adds:
-]
    
-
-
-
    
-
      
-
    1. 
-
      
-star bullet 1 ("what's the effect of calling assign(T&) on a
-zero-sized array?[..]");
-
      
-
      
-assign has been renamed to fill and the semantic of fill is now
-defined in terms of
-the free algorithm fill_n, which is well-defined for this situation.
-
      
-
      2. 
-
    2. 
-
      
-star bullet 3 ("it would be desiderable to have a static const data
-member..."):
-
      
-
      
-It seems that tuple_size<array<T, N> >::value as of 23.3.1.7 [array.tuple] does
-provide this functionality now.
-
      
-
      3. 
-
    
-
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-
    
-Alisdair to address by the next meeting, or declare NAD.
-
    
-
    
-Moved to Tentatively NAD.
-
    
-
    
-
-
-
-
    Proposed resolution:
    
-
    
-
    
-
-
-
    [
-Kona (2007): requirements on zero sized tr1::arrays and other details
-Issue 617: std::array is a sequence that doesn't satisfy the sequence
-requirements? Alisdair will prepare a paper. Proposed Disposition: Open
-]
    
-
-
-
-
-
-
    
-
    594. Disadvantages of defining Swappable in terms of CopyConstructible and Assignable
    
-
    Section: X [utility.arg.requirements] Status: Open
- Submitter: Niels Dekker Opened: 2006-11-02  Last modified: 2009-07-26
    
-
    View other active issues in [utility.arg.requirements].
    
-
    View all other issues in [utility.arg.requirements].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-It seems undesirable to define the Swappable requirement in terms of
-CopyConstructible and Assignable requirements. And likewise, once the
-MoveConstructible and MoveAssignable requirements (N1860) have made it
-into the Working Draft, it seems undesirable to define the Swappable
-requirement in terms of those requirements. Instead, it appears
-preferable to have the Swappable requirement defined exclusively in
-terms of the existence of an appropriate swap function.
-
    
 
    
-Section 20.1.4 [lib.swappable] of the current Working Draft (N2009)
-says:
-
    
-
    
-The Swappable requirement is met by satisfying one or more of the
-following conditions:
    
-
      
-
    • 
-T is Swappable if T satisfies the CopyConstructible requirements
-(20.1.3) and the Assignable requirements (23.1);
-
      • 
-
    • 
-T is Swappable if a namespace scope function named swap exists in the
-same namespace as the definition of T, such that the expression
-swap(t,u) is valid and has the semantics described in Table 33.
-
      • 
-
    
-
    
 I can think of three disadvantages of this definition:
+
    
 
      
 
    1. 
+
      
 If a client's type T satisfies the first condition (T is both
 CopyConstructible and Assignable), the client cannot stop T from
 satisfying the Swappable requirement without stopping T from
 satisfying the first condition.
+
      
 
      
 A client might want to stop T from satisfying the Swappable
 requirement, because swapping by means of copy construction and
@@ -4815,8 +3537,10 @@ stopping T from satisfying the Swappable requirement.
 
      
 
      2. 
 
    2. 
+
      
 A client's type T that does not satisfy the first condition can not be
 made Swappable by providing a specialization of std::swap for T.
+
      
 
      
 While I'm aware about the fact that people have mixed feelings about
 providing a specialization of std::swap, it is well-defined to do so.
@@ -4827,11 +3551,13 @@ effect as satisfying the Swappable requirement.
 
      
 
      3. 
 
    3. 
+
      
 For a client's type T that satisfies both conditions of the Swappable
 requirement, it is not specified which of the two conditions prevails.
 After reading section 20.1.4 [lib.swappable], one might wonder whether
 objects of T will be swapped by doing copy construction and
 assignments, or by calling the swap function of T.
+
      
 
      
 I'm aware that the intention of the Draft is to prefer calling the
 swap function of T over doing copy construction and assignments. Still
@@ -4878,6 +3604,15 @@ Recommend NAD.  Solved by
 Moved to Open.  Waiting for non-concepts draft.
 
    
 
+
    [
+2009-11-08 Howard adds:
+]
    
+
+
+
    
+This issue is very closely related to 742.
+
    
+
 
 
    Proposed resolution:
    
@@ -4910,144 +3645,25 @@ within the namespace std, and has the semantics described in Table 33.
 
 
 
    
-
    617. std::array is a sequence that doesn't satisfy the sequence requirements?
    
-
    Section: 23.3.1 [array] Status: Tentatively NAD
- Submitter: Bo Persson Opened: 2006-12-30  Last modified: 2009-07-16
    
-
    View other active issues in [array].
    
-
    View all other issues in [array].
    
-
    View all issues with Tentatively NAD status.
    
+
    625. mixed up Effects and Returns clauses
    
+
    Section: 17 [library] Status: Open
+ Submitter: Martin Sebor Opened: 2007-01-20  Last modified: 2009-10-20
    
+
    View other active issues in [library].
    
+
    View all other issues in [library].
    
+
    View all issues with Open status.
    
+
    Duplicate of: 895
    Discussion:
    
-
    
-The <array> header is given under 23.3 [sequences].
-23.3.1 [array]/paragraph 3 says:
-
    
-
    
-"Unless otherwise specified, all array operations are as described in
-23.2 [container.requirements]".
-
    
-
    
-However, array isn't mentioned at all in section 23.2 [container.requirements].
-In particular, Table 82 "Sequence requirements" lists several operations (insert, erase, clear) 
-that std::array does not have in 23.3.1 [array].
-
    
-
    
-Also, Table 83 "Optional sequence operations" lists several operations that 
-std::array does have, but array isn't mentioned.
-
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-
    
-The real issue seems to be different than what is described here.
-Non-normative text says that std::array is a sequence container, but
-there is disagreement about what that really means. There are two
-possible interpretations:
-
    
-
      
-
    1. 
-a sequence container is one that satisfies all sequence container requirements
-
      2. 
-
    2. 
-a sequence container is one that satisfies some of the sequence
-container requirements. Any operation that the container supports is
-specified by one or more sequence container requirements, unless that
-operation is specifically singled out and defined alongside the
-description of the container itself.
-
      3. 
-
    
-
    
-Move to Tentatively NAD.
-
    
-
    
-
-
    [
-2009-07-15 Loďc Joly adds:
-]
    
-
-
-
    
-
    
-The section 23.2.3 [sequence.reqmts]/1 states that array is a sequence. 23.2.3 [sequence.reqmts]/3
-introduces table 83, named Sequence container requirements. This seems
-to me to be defining the requirements for all sequences. However, array
-does not follow all of this requirements (this can be read in the array
-specific section, for the standard is currently inconsistent).
-
    
-
-
    
-Proposed resolution 1 (minimal change): 
-
    
-
    
-
    
-Say that array is a container, that in addition follows only some of the
-sequence requirements, as described in the array section:
-
    
-
-
    
-The library provides five three basic kinds of sequence containers: array,
-vector, 
-forward_list, list, and deque. In addition, array
-and forward_list follows some of the requirements 
-of sequences, as described in their respective sections.
-
    
-
-
    
-
-
    
-Proposed resolution 2 (most descriptive description, no full wording provided): 
-
    
-
    
-Introduce the notion of a Fixed Size Sequence, with it requirement table
-that would be a subset of the current Sequence container. array would be
-the only Fixed Size Sequence (but dynarray is in the queue for TR2).
-Sequence requirements would now be requirements in addition to Fixed
-Size Sequence requirements (it is currently in addition to container).
-
    
-
    
-
-
    [
-2009-07 Frankfurt:
-]
    
-
-
-
    
-Move to NAD Editorial
-
    
-
-
-
-
    Proposed resolution:
    
-
    
-
    
-
-
-
-
-
-
    
-
    625. mixed up Effects and Returns clauses
    
-
    Section: 17 [library] Status: Tentatively NAD
- Submitter: Martin Sebor Opened: 2007-01-20  Last modified: 2009-07-15
    
-
    View other active issues in [library].
    
-
    View all other issues in [library].
    
-
    View all issues with Tentatively NAD status.
    
-
    Duplicate of: 895
    
-
    Discussion:
    
- 
    
-
-Many member functions of basic_string are overloaded,
-with some of the overloads taking a string argument,
-others value_type*, others size_type, and
-others still iterators. Often, the requirements on one of
-the overloads are expressed in the form of Effects,
-Throws, and in the Working Paper
-(N2134)
-also Remark clauses, while those on the rest of the overloads
-via a reference to this overload and using a Returns clause.
+ 
    
+
+Many member functions of basic_string are overloaded,
+with some of the overloads taking a string argument,
+others value_type*, others size_type, and
+others still iterators. Often, the requirements on one of
+the overloads are expressed in the form of Effects,
+Throws, and in the Working Paper
+(N2134)
+also Remark clauses, while those on the rest of the overloads
+via a reference to this overload and using a Returns clause.
 
    
@@ -5167,187 +3783,20 @@ is confusing, especially now that requires is a new keyword.
 Move to Tentatively NAD.
 
 
-
-
-
    Proposed resolution:
    
-
    
-
    
-
-
-
-
-
-
    
-
    630. arrays of valarray
    
-
    Section: 26.6.2.1 [valarray.cons] Status: Ready
- Submitter: Martin Sebor Opened: 2007-01-28  Last modified: 2009-07-15
    
-
    View all other issues in [valarray.cons].
    
-
    View all issues with Ready status.
    
-
    Discussion:
    
-        
    
-
-Section 26.2 [numeric.requirements], p1     suggests     that     a
-valarray  specialization on  a  type T  that
-satisfies  the requirements enumerated  in the  paragraph is  itself a
-valid  type   on  which  valarray   may  be  instantiated
-(Footnote       269        makes       this       clear).        I.e.,
-valarray<valarray<T>  > is  valid as  long as
-T   is   valid.    However,  since   implementations   of
-valarray are permitted to initialize storage allocated by
-the class by  invoking the default ctor of  T followed by
-the    copy    assignment    operator,   such    implementations    of
-valarray   wouldn't  work  with   (perhaps  user-defined)
-specializations of valarray whose assignment operator had
-undefined behavior when the size of its argument didn't match the size
-of *this.  By "wouldn't work" I mean that it would
-be  impossible  to resize  such  an array  of  arrays  by calling  the
-resize() member  function on it if the  function used the
-copy  assignment operator  after constructing  all elements  using the
-default  ctor (e.g.,  by invoking  new  value_type[N]) to
-obtain default-initialized storage) as it's permitted to do.
-
-        
    
-        
    
-
-Stated      more     generally,      the      problem     is      that
-valarray<valarray<T>  >::resize(size_t) isn't
-required or  guaranteed to have well-defined semantics  for every type
-T     that      satisfies     all     requirements     in
-26.2 [numeric.requirements].
-
-        
    
-        
    
-
-I  believe  this  problem  was  introduced  by  the  adoption  of  the
-resolution                outlined                in                N0857,
-Assignment  of  valarrays,  from  1996.   The  copy  assignment
-operator  of  the original  numerical  array  classes  proposed in  N0280,
-as      well       as      the      one       proposed      in      N0308
-(both  from 1993), had  well-defined semantics  for arrays  of unequal
-size (the  latter explicitly  only when *this  was empty;
-assignment of non empty arrays of unequal size was a runtime error).
-
-        
    
-        
    
-
-The  justification for  the  change given  in  N0857 was the "loss  of
-performance [deemed]  only significant  for very simple  operations on
-small arrays or for architectures with very few registers."
-
-        
    
-        
    
-
-Since tiny  arrays on a  limited subset of hardware  architectures are
-likely  to  be  an   exceedingly  rare  case  (despite  the  continued
-popularity of  x86) I  propose to revert  the resolution and  make the
-behavior    of   all   valarray    assignment   operators
-well-defined even  for non-conformal  arrays (i.e., arrays  of unequal
-size).   I have implemented  this change  and measured  no significant
-degradation  in performance in  the common  case (non-empty  arrays of
-equal size).  I  have measured a 50% (and in  some cases even greater)
-speedup  in the  case of  assignments to  empty arrays  versus calling
-resize()  first followed  by  an invocation  of the  copy
-assignment operator.
-
-        
    
-
 
    [
-Bellevue:
+2009 Santa Cruz:
 ]
    
-If no proposed wording by June meeting, this issue should be closed NAD.
+Move to Open.  Martin will work on proposed wording.
 
    
 
-
    [
-2009-07 Frankfurt
-]
    
 
 
-
    
-
    
-Move resolution 1 to Ready.
-
    
+
    Proposed resolution:
    
 
    
-Howard: second resolution has been commented out (made invisible).
-Can be brought back on demand.
 
    
-
    
-
-
-
-
    Proposed resolution:
    
-        
    
-
-Change 26.6.2.2 [valarray.assign], p1 as follows:
-
-        
    
-        
    
-            
    
-                
-
-valarray<T>& operator=(const valarray<T>& x);
-
-                
-            
    
-            
    
-
--1- Each element of the *this array is assigned the value
-of  the  corresponding  element   of  the  argument  array.   The
-resulting behavior is undefined if When the length of
-the  argument  array  is  not   equal  to  the  length  of  the  *this
-array.  resizes  *this  to make  the  two
-arrays     the      same     length,     as      if     by     calling
-resize(x.size()), before performing the assignment.
-
-            
    
-        
    
-        
    
-
-And  add a new  paragraph just  below paragraph  1 with  the following
-text:
-
-        
    
-        
    
-            
    
-
--2- Postcondition: size() == x.size().
-
-            
    
-        
    
-        
    
-
-Also add the following paragraph to 26.6.2.2 [valarray.assign], immediately after p4:
-
-        
    
-        
    
-            
    
-
--?- When the length,  N of the array referred
-to by the  argument is not equal to  the length of *this,
-the  operator resizes *this  to make  the two  arrays the
-same  length, as if  by calling  resize(N), before
-performing the assignment.
-
-            
    
-        
    
-
-
    [
-pre-Sophia Antipolis, Martin adds the following compromise wording, but
-prefers the original proposed resolution:
-]
    
-
-
-
-
-
-
-
    [
-Kona (2007): Gaby to propose wording for an alternative resolution in
-which you can assign to a valarray of size 0, but not to any other
-valarray whose size is unequal to the right hand side of the assignment.
-]
    
 
 
 
@@ -5355,11 +3804,11 @@ which you can assign to a valarray of size 0, but not to any other
 
 
    631. conflicting requirements for BinaryPredicate
    
-
    Section: 25 [algorithms] Status: Open
- Submitter: James Kanze Opened: 2007-01-31  Last modified: 2009-07-28
    
+
    Section: 25 [algorithms] Status: Review
+ Submitter: James Kanze Opened: 2007-01-31  Last modified: 2009-10-24
    View other active issues in [algorithms].
    View all other issues in [algorithms].
    
-
    View all issues with Open status.
    
+
    View all issues with Review status.
    Discussion:
    
 The general requirements for BinaryPredicate (in 25 [algorithms]/8) contradict the implied specific requirements for
@@ -5378,7 +3827,7 @@ part of the signature, it should work correctly in the context of if
 
    
-In the description of upper_bound (25.5.3.2 [upper.bound]/2), however, the use is described as
+In the description of upper_bound (25.4.3.2 [upper.bound]/2), however, the use is described as
 "!comp(value, e)", where e is an
 element of the sequence (a result of dereferencing
 *first).
@@ -5403,6 +3852,19 @@ and upper_bound to work withoutt these changes.
 ]
    
 
 
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Move to Review. The small problem with the "iterator type"
+will be fixed. The cited functions (lower_bound, uppwer_bound,
+equal_range) don't actually use BinaryPredicate , and where it is used,
+it is consistent with  [algorithm]/8, so the main complaint of the issue
+is moot.
+
    
+
 
 
 
    Proposed resolution:
    
@@ -5450,7 +3912,7 @@ post San Francisco:
 
 
    
 Solved by
-N2759.
+N2759.
 
    
 
 
@@ -5459,1286 +3921,1175 @@ Solved by
 
 
 
    
-
    635. domain of allocator::address
    
-
    Section: X [allocator.requirements] Status: Open
- Submitter: Howard Hinnant Opened: 2007-02-08  Last modified: 2009-07-28
    
-
    View other active issues in [allocator.requirements].
    
-
    View all other issues in [allocator.requirements].
    
-
    View all issues with Open status.
    
+
    671. precision of hexfloat
    
+
    Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Ready
+ Submitter: John Salmon Opened: 2007-04-20  Last modified: 2009-10-21
    
+
    View other active issues in [facet.num.put.virtuals].
    
+
    View all other issues in [facet.num.put.virtuals].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
-The table of allocator requirements in X [allocator.requirements] describes
-allocator::address as:
+I am trying to understand how TR1 supports hex float (%a) output.
 
    
-
    a.address(r)
-a.address(s)
-
    
 
    
-where r and s are described as:
+As far as I can tell, it does so via the following:
 
    
-
    
-a value of type X::reference obtained by the expression *p. 
-
    
-
 
    
-and p is 
+8.15 Additions to header <locale> [tr.c99.locale]
 
    
-
-
    
-a value of type X::pointer, obtained by calling a1.allocate, 
-where a1 == a
-
    
-
 
    
-This all implies that to get the address of some value of type T that
-value must have been allocated by this allocator or a copy of it.
+In subclause 22.4.2.2.2 [facet.num.put.virtuals], Table 58 Floating-point conversions, after
+the line:
+floatfield == ios_base::scientific %E
 
    
-
 
    
-However sometimes container code needs to compare the address of an external value of
-type T with an internal value.  For example list::remove(const T& t)
-may want to compare the address of the external value t with that of a value
-stored within the list.  Similarly vector or deque insert may
-want to make similar comparisons (to check for self-referencing calls).
+add the two lines:
+
    
+
    floatfield == ios_base::fixed | ios_base::scientific && !uppercase %a
+floatfield == ios_base::fixed | ios_base::scientific %A 2
+
    
+
    
+[Note: The additional requirements on print and scan functions, later
+in this clause, ensure that the print functions generate hexadecimal
+floating-point fields with a %a or %A conversion specifier, and that
+the scan functions match hexadecimal floating-point fields with a %g
+conversion specifier.  end note]
+
    
+
    
+Following the thread, in 22.4.2.2.2 [facet.num.put.virtuals], we find:
+
    
+
    
+For conversion from a floating-point type, if (flags & fixed) != 0 or
+if str.precision() > 0, then str.precision() is specified in the
+conversion specification.
 
    
-
 
    
-Mandating that allocator::address can only be called for values which the
-allocator allocated seems overly restrictive.
+This would seem to imply that when floatfield == fixed|scientific, the
+precision of the conversion specifier is to be taken from
+str.precision().  Is this really what's intended?  I sincerely hope
+that I'm either missing something or this is an oversight.  Please
+tell me that the committee did not intend to mandate that hex floats
+(and doubles) should by default be printed as if by %.6a.
 
    
 
 
    [
-post San Francisco:
+Howard: I think the fundamental issue we overlooked was that with %f,
+%e, %g, the default precision was always 6.  With %a the default
+precision is not 6, it is infinity.  So for the first time, we need to
+distinguish between the default value of precision, and the precision
+value 6.
 ]
    
 
 
-
    
-Pablo recommends NAD Editorial, solved by
-N2768.
-
    
-
 
    [
-2009-04-28 Pablo adds:
+2009-07 Frankfurt
 ]
    
 
 
 
    
-Tentatively-ready NAD Editorial as fixed by
-N2768.
-
    
+
    
+Leave this open for Robert and Daniel to work on.
+
    
+
    
+Straw poll: Disposition?
+
    
+
      
+
    • Default is %.6a (i.e. NAD): 2
      • 
+
    • Always %a (no precision): 6
      • 
+
    • precision(-1) == %a: 3
      • 
+
    
+
    
+Daniel and Robert have direction to write up wording for the "always %a" solution.
+
    
 
 
    [
-2009-07 Frankfurt
+2009-07-15 Robert provided wording.
 ]
    
 
-
-
    
-Fixed by N2768.
 
    
 
 
    [
-2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+2009-10 Santa Cruz:
 ]
    
 
 
+
    
+Move to Ready.
+
    
+
 
 
 
    Proposed resolution:
    
 
    
-Change X [allocator.requirements]:
+Change 22.4.2.2.2 [facet.num.put.virtuals], Stage 1, under p5 (near the end
+of Stage 1):
 
    
 
 
    
-
    
-r : a value of type X::reference obtained by the expression *p.
-
    
-
    
-s : a value of type X::const_reference obtained by the 
-expression *q or by conversion from a value r.
-
    
+For conversion from a floating-point type, str.precision() is specified
+as precision in the conversion specification
+if floatfield != (ios_base::fixed | ios_base::scientific), else no
+precision is specified.
 
    
 
-
    [
-post Oxford:  This would be rendered NAD Editorial by acceptance of
-N2257.
-]
    
 
 
 
    [
-Kona (2007):  This issue is section 8 of N2387.  There was some discussion of it but
-no resolution to this issue was recorded.  Moved to Open.
+Kona (2007): Robert volunteers to propose wording.
 ]
    
 
 
 
 
 
-
-
 
    
-
    659. istreambuf_iterator should have an operator->()
    
-
    Section: 24.6.3 [istreambuf.iterator] Status: Ready
- Submitter: Niels Dekker Opened: 2007-03-25  Last modified: 2009-07-15
    
-
    View all other issues in [istreambuf.iterator].
    
-
    View all issues with Ready status.
    
+
    676. Moving the unordered containers
    
+
    Section: 23.5 [unord] Status: Review
+ Submitter: Howard Hinnant Opened: 2007-05-05  Last modified: 2009-10-29
    
+
    View all other issues in [unord].
    
+
    View all issues with Review status.
    
 
    Discussion:
    
 
    
-Greg Herlihy has clearly demonstrated that a user defined input
-iterator should have an operator->(), even if its
-value type is a built-in type (comp.std.c++, "Re: Should any iterator
-have an operator->() in C++0x?", March 2007).  And as Howard
-Hinnant remarked in the same thread that the input iterator
-istreambuf_iterator doesn't have one, this must be a
-defect!
-
    
-
    
-Based on Greg's example, the following code demonstrates the issue:
-
     #include <iostream> 
- #include <fstream>
- #include <streambuf> 
-
- typedef char C;
- int main ()
- {
-   std::ifstream s("filename", std::ios::in);
-   std::istreambuf_iterator<char> i(s);
-
-   (*i).~C();  // This is well-formed...
-   i->~C();  // ... so this should be supported!
- }
-
    
+Move semantics are missing from the unordered containers.  The proposed
+resolution below adds move-support consistent with
+N1858
+and the current working draft.
+
    
 
 
    
-Of course, operator-> is also needed when the value_type of
-istreambuf_iterator is a class.
-
    
-
    
-The operator-> could be implemented in various ways.  For instance,
-by storing the current value inside the iterator, and returning its
-address.  Or by returning a proxy, like operator_arrow_proxy, from
-http://www.boost.org/boost/iterator/iterator_facade.hpp
-
    
-
    
-I hope that the resolution of this issue will contribute to getting a
-clear and consistent definition of iterator concepts.
+The current proposed resolution simply lists the requirements for each function.
+These might better be hoisted into the requirements table for unordered associative containers.
+Futhermore a mild reorganization of the container requirements could well be in order.
+This defect report is purposefully ignoring these larger issues and just focusing
+on getting the unordered containers "moved".
 
    
 
 
    [
-Kona (2007): The proposed resolution is inconsistent because the return
-type of istreambuf_iterator::operator->() is specified to be pointer,
-but the proposed text also states that "operator-> may return a proxy."
+2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
 ]
    
 
 
 
    [
-Niels Dekker (mailed to Howard Hinnant):
+2009-10-17 Removed rvalue-swaps from wording.
 ]
    
 
-
    
-
    
-The proposed resolution does
-not seem inconsistent to me. istreambuf_iterator::operator->() should
-have istreambuf_iterator::pointer as return type, and this return type
-may in fact be a proxy.
-
    
-
    
-AFAIK, the resolution of 445 ("iterator_traits::reference
-unspecified for some iterator categories") implies that for any iterator
-class Iter, the return type of operator->() is Iter::pointer, by
-definition.  I don't think Iter::pointer needs to be a raw pointer.
-
    
-
    
-Still I wouldn't mind if the text "operator-> may return a proxy" would
-be removed from the resolution. I think it's up to the library
-implementation, how to implement istreambuf_iterator::operator->().  As
-longs as it behaves as expected: i->m should have the same effect as
-(*i).m. Even for an explicit destructor call, i->~C().  The main issue
-is just: istreambuf_iterator should have an operator->()!
-
    
-
    
 
 
    [
-2009-04-30 Alisdair adds:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-Note that operator-> is now a requirement in the InputIterator concept, so
-this issue cannot be ignored or existing valid programs will break when
-compiled with an 0x library.
+Move to Review. Alisdair will review proposed wording.
 
    
 
 
    [
-2009-05-29 Alisdair adds:
+2009-10-29 Daniel updates wording.
 ]
    
 
 
-
    
-
    
-I agree with the observation that in principle the type 'pointer' may be a
-proxy, and the words highlighting this are redundant.
-
    
-
    
-However, in the current draught pointer is required to be exactly 'charT *'
-by the derivation from std::iterator.  At a minimum, the 4th parameter of
-this base class template should become unspecified.  That permits the
-introduction of a proxy as a nested class in some further undocumented (not
-even exposition-only) base.
-
    
-
    
-It also permits the istream_iterator approach where the cached value is
-stored in the iterator itself, and the iterator serves as its own proxy for
-post-increment operator++ - removing the need for the existing
-exposition-only nested class proxy.
-
    
-
    
-Note that the current proxy class also has exactly the right properties to
-serve as the pointer proxy too.  This is likely to be a common case where an
-InputIterator does not hold internal state but delegates to another class.
-
    
-
    
-Proposed Resolution:
-
    
-
    
-In addition to the current proposal:
-
    
-
    
-24.6.3 [istreambuf.iterator]
-
    
-
    template<class charT, class traits = char_traits<charT> >
-class istreambuf_iterator
-  : public iterator<input_iterator_tag, charT,
-                    typename traits::off_type, charT* unspecified, charT> {
-
    
-
    
 
-
    [
-2009-07 Frankfurt
-]
    
 
+
    Proposed resolution:
    
 
-
    
-
    
-Move the additional part into the proposed resolution, and wrap the
-descriptive text in a Note.
-
    
-
    [Howard: done.]
    
+
    unordered_map
    
 
 
    
-Move to Ready.
+Change 23.5.1 [unord.map]:
 
    
-
    
 
+
    class unordered_map
+{
+    ...
+    unordered_map(const unordered_map&);
+    unordered_map(unordered_map&&);
+    ~unordered_map();
+    unordered_map& operator=(const unordered_map&);
+    unordered_map& operator=(unordered_map&&);
+    ...
+    // modifiers 
+    std::pair<iterator, bool> insert(const value_type& obj); 
+    template <class P> pair<iterator, bool> insert(P&& obj);
+    iterator       insert(const_iterator hint, const value_type& obj);
+    template <class P> iterator       insert(const_iterator hint, P&& obj);
+    ...
+    mapped_type& operator[](const key_type& k);
+    mapped_type& operator[](key_type&& k);
+    ...
+};
 
+
    
 
-
    Proposed resolution:
    
 
    
-Add to the synopsis in 24.6.3 [istreambuf.iterator]:
+Add to 23.5.1.1 [unord.map.cnstr]:
 
    
 
-
    charT operator*() const;
-pointer operator->() const;
-istreambuf_iterator<charT,traits>& operator++();
-
    
+
    
+
    template <class InputIterator>
+  unordered_map(InputIterator f, InputIterator l, 
+                size_type n = implementation-defined, 
+                const hasher& hf = hasher(), 
+                const key_equal& eql = key_equal(), 
+                const allocator_type& a = allocator_type());
+
    
+
+
    
+
+Requires: If the iterator's dereference operator returns an
+lvalue or a const rvalue pair<key_type, mapped_type>,
+then both key_type and mapped_type shall be
+CopyConstructible.
+
+
    
+
    
 
 
    
-24.6.3 [istreambuf.iterator]
+Add to 23.5.1.2 [unord.map.elem]:
 
    
 
-
    template<class charT, class traits = char_traits<charT> >
-class istreambuf_iterator
-  : public iterator<input_iterator_tag, charT,
-                    typename traits::off_type, charT* unspecified, charT> {
-
    
+
    
 
-
    
-Change 24.6.3 [istreambuf.iterator], p1:
-
    
+
    mapped_type& operator[](const key_type& k);
    
 
-
    
-The class template istreambuf_iterator reads successive
-characters from the streambuf for which it was constructed.
-operator* provides access to the current input character, if
-any. [Note: operator-> may return a proxy. —
-end note] Each time
-operator++ is evaluated, the iterator advances to the next
-input character. If the end of stream is reached
-(streambuf_type::sgetc() returns traits::eof()), the
-iterator becomes equal to the end of stream iterator value. The default
-constructor istreambuf_iterator() and the constructor
-istreambuf_iterator(0) both construct an end of stream iterator
-object suitable for use as an end-of-range.
-
    
+
    
+
    ...
    
+
    
+Requires: key_type shall be CopyConstructible
+and mapped_type shall be DefaultConstructible.
+
    
+
    
 
+
    mapped_type& operator[](key_type&& k);
    
 
+
    
+
    
+Effects: If the unordered_map does not already contain an
+element whose key is equivalent to k , inserts the value
+std::pair<const key_type, mapped_type>(std::move(k), mapped_type()).
+
    
 
+
    
+Requires: mapped_type shall be DefaultConstructible.
+
    
 
+
    
+Returns: A reference to x.second, where x is the
+(unique) element whose key is equivalent to k.
+
    
 
+
    
 
+
    
 
-
    
-
    668. money_get's empty minus sign
    
-
    Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Review
- Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2009-07-20
    
-
    View other active issues in [locale.money.get.virtuals].
    
-
    View all other issues in [locale.money.get.virtuals].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
 
    
-22.4.6.1.2 [locale.money.get.virtuals], para 3 says:
+Add new section [unord.map.modifiers]:
 
    
 
-
    
-If pos or neg is empty, the sign component is
-optional, and if no sign is detected, the result is given the sign
-that corresponds to the source of the empty string.
-
    
+
    
+
    pair<iterator, bool> insert(const value_type& x);
+template <class P> pair<iterator, bool> insert(P&& x);
+iterator       insert(const_iterator hint, const value_type& x);
+template <class P> iterator       insert(const_iterator hint, P&& x);
+template <class InputIterator>
+  void insert(InputIterator first, InputIterator last);
+
    
 
-
    
-The following objection has been raised:
-
    
+
    
+
    
+Requires: Those signatures taking a const value_type& parameter
+requires both the key_type and the mapped_type to be
+CopyConstructible.
+ If P is instantiated as a reference
+type, then the argument x is copied from. Otherwise x
+is considered to be an rvalue as it is converted to value_type
+and inserted into the unordered_map. Specifically, in such
+cases CopyConstructible is not required for key_type or
+mapped_type unless the conversion from P specifically
+requires it (e.g. if P is a tuple<const key_type,
+mapped_type>, then key_type must be
+CopyConstructible).
+
    
 
-
    
-A negative_sign of "" means "there is no
-way to write a negative sign" not "any null sequence is a negative
-sign, so it's always there when you look for it".
-
    
+
    
+The signature taking InputIterator
+parameters requires CopyConstructible of both
+key_type and mapped_type if the dereferenced
+InputIterator returns an lvalue or const rvalue
+value_type.
+
    
 
-
    
-[Plum ref _222612Y32]
-
    
+
    
 
-
    [
-Kona (2007): Bill to provide proposed wording and interpretation of existing wording.
-]
    
+
    
 
+
    unordered_multimap
    
 
 
    
-Related to 669.
+Change 23.5.2 [unord.multimap]:
 
    
 
-
    [
-2009-05-17 Howard adds:
-]
    
+
    class unordered_multimap
+{
+    ...
+    unordered_multimap(const unordered_multimap&);
+    unordered_multimap(unordered_multimap&&);
+    ~unordered_multimap();
+    unordered_multimap& operator=(const unordered_multimap&);
+    unordered_multimap& operator=(unordered_multimap&&);
+    ...
+    // modifiers 
+    iterator insert(const value_type& obj); 
+    template <class P> iterator insert(P&& obj);
+    iterator       insert(const_iterator hint, const value_type& obj);
+    template <class P> iterator       insert(const_iterator hint, P&& obj);
+    ...
+};
 
+
    
 
-
    
 
    
-I disagree that a negative_sign of "" means "there is no
-way to
-write a negative sign". The meaning requires the sentences of
-22.4.6.1.2 [locale.money.get.virtuals] p3 following that quoted above
-to be
-taken into account:
+Add to 23.5.2.1 [unord.multimap.cnstr]:
 
    
 
 
    
--3- ... If pos or neg is empty, the sign component is
-optional, and if no sign is detected, the result is given the sign that
-corresponds to the source of the empty string. Otherwise, the character
-in the indicated position must match the first character of pos
-or neg, and the result is given the corresponding sign. If the
-first character of pos is equal to the first character of
-neg, or if both strings are empty, the result is given a
-positive sign.
+
    template <class InputIterator>
+  unordered_multimap(InputIterator f, InputIterator l, 
+                size_type n = implementation-defined, 
+                const hasher& hf = hasher(), 
+                const key_equal& eql = key_equal(), 
+                const allocator_type& a = allocator_type());
+
    
+
+
    
+
+Requires: If the iterator's dereference operator returns an
+lvalue or a const rvalue pair<key_type, mapped_type>,
+then both key_type and mapped_type shall be
+CopyConstructible.
+
+
    
 
    
 
 
    
-So a negative_sign of "" means "there is no way to write a
-negative sign" only when positive_sign is also "".  However
-when negative_sign is "" and postive_sign.size() >
-0, then one writes a negative value by not writing the
-postive_sign in the position indicated by
-money_base::sign.
-For example:
+Add new section [unord.multimap.modifiers]:
 
    
 
-
    pattern = {symbol, sign, value, none}
-positive_sign = "+"
-negative_sign = ""
-$123   // a negative value, using optional sign
-$+123  // a positive value
-$-123  // a parse error
-
    
+
    
+
    iterator insert(const value_type& x);
+template <class P> iterator       insert(P&& x);
+iterator       insert(const_iterator hint, const value_type& x);
+template <class P> iterator       insert(const_iterator hint, P&& x);
+template <class InputIterator>
+  void insert(InputIterator first, InputIterator last);
+
    
 
-
    
-And:
-
    
+
    
+
    
+Requires: Those signatures taking a const value_type& parameter
+requires both the key_type and the mapped_type to be
+CopyConstructible.
+If P is instantiated as a reference
+type, then the argument x is copied from. Otherwise x
+is considered to be an rvalue as it is converted to value_type
+and inserted into the unordered_multimap. Specifically, in such
+cases CopyConstructible is not required for key_type or
+mapped_type unless the conversion from P specifically
+requires it (e.g. if P is a tuple<const key_type,
+mapped_type>, then key_type must be
+CopyConstructible).
+
    
 
-
    pattern = {symbol, sign, value, none}
-positive_sign = ""
-negative_sign = ""
-$123   // a positive value, no sign possible
-$+123  // a parse error
-$-123  // a parse error
-
    
+
    
+The signature taking InputIterator
+parameters requires CopyConstructible of both
+key_type and mapped_type if the dereferenced
+InputIterator returns an lvalue or const rvalue
+value_type.
+
    
+
    
 
+
    
+
+
    unordered_set
    
 
 
    
-And (regarding 669):
+Change 23.5.3 [unord.set]:
 
    
 
-
    pattern = {symbol, sign, value, none}
-positive_sign = "-"
-negative_sign = "-"
-$123   // a parse error, sign is mandatory
-$+123  // a parse error
-$-123  // a positive value
+
    class unordered_set
+{
+    ...
+    unordered_set(const unordered_set&);
+    unordered_set(unordered_set&&);
+    ~unordered_set();
+    unordered_set& operator=(const unordered_set&);
+    unordered_set& operator=(unordered_set&&);
+    ...
+    // modifiers 
+    std::pair<iterator, bool> insert(const value_type& obj); 
+    pair<iterator, bool> insert(value_type&& obj);
+    iterator       insert(const_iterator hint, const value_type& obj);
+    iterator       insert(const_iterator hint, value_type&& obj);
+    ...
+};
 
    
 
-
 
    
-The text seems both unambiguous and clear to me.  I recommend NAD for
-both this issue and 669.  However I would have no
-objection to adding examples such as those above.
+Add to 23.5.3.1 [unord.set.cnstr]:
 
    
-
    
-
-
    [
-Batavia (2009-05):
-]
    
 
 
    
-
    
-This discussion applies equally to issue 669 (q.v.).
-Howard has added examples above,
-and recommends either NAD or a resolution that adds his (or similar) examples
-to the Working Paper.
-
    
-
    
-Alan would like to rewrite paragraph 3.
-
    
-
    
-We recommend moving to NAD.
-Anyone who feels strongly about adding the examples
-is invited to submit corresponding wording.
-We further recommend issue 669 be handled identically.
-
    
-
    
-
-
    [
-2009-07-14 Alan reopens with improved wording.
-]
    
-
-
-
    [
-2009-07 Frankfurt
-]
    
-
+
    template <class InputIterator>
+  unordered_set(InputIterator f, InputIterator l, 
+                size_type n = implementation-defined, 
+                const hasher& hf = hasher(), 
+                const key_equal& eql = key_equal(), 
+                const allocator_type& a = allocator_type());
+
    
 
-
    
-No consensus for closing as NAD.  Leave in Review.
+
    
+
+Requires: If the iterator's dereference operator returns an
+lvalue or a const rvalue value_type, then the
+value_type shall be CopyConstructible.
+
+
    
 
    
 
-
-
-
    Proposed resolution:
    
 
    
-Change 22.4.6.1.2 [locale.money.get.virtuals] p3:
+Add new section [unord.set.modifiers]:
 
    
 
 
    
--3- 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 the string are required after all the other format components.
-[Example: If showbase is off�, then for a neg
-value of "()" and a currency symbol of "L", in "(100 L)" the "L" is
-consumed; but if neg is "-", the "L" in "-100 L" is not
-consumed. -- end example] If pos or neg is
-empty, the sign component is optional, and if no sign is detected, the
-result is given the sign that corresponds to the source of the empty
-string. Otherwise, the character in the indicated position must match
-the first character of pos or neg, and the result is
-given the corresponding sign. If the first character of pos is
-equal to the first character of neg, or if both strings are
-empty, the result is given a positive sign.
+
    pair<iterator, bool> insert(const value_type& x);
+pair<iterator, bool> insert(value_type&& x);
+iterator       insert(const_iterator hint, const value_type& x);
+iterator       insert(const_iterator hint, value_type&& x);
+template <class InputIterator>
+  void insert(InputIterator first, InputIterator last);
+
    
 
-The sign pattern strings pos and neg are returned by
-mp.positive_sign() and mp.negative_sign() respectively. A sign pattern
-is matched if its first character is recognized in s in the position
-indicated by sign in the format pattern, or if the pattern is empty and
-there is no sign recognized in s. A match is required to occur. If both
-patterns are matched, the result is given a positive sign, otherwise the
-result is given the sign corresponding to the matched pattern. 
-If the pattern contains more than one character, the characters after the first 
-must be matched in s after all other format components. 
-If any sign
-characters are matched, s is consumed up to and including those characters.
-[Example: If showbase is off, then for a neg
-value of "()" and a currency symbol of "L", in
-"(100 L)" the entire string is consumed; but for a neg
-value of "-", in "-100 L", the string is consumed
-through the second "0" (the space and "L" are not consumed). — end
-example] 
-
    
+
    
 
+
    
+Requires: Those signatures taking a const
+value_type& parameter requires the value_type to
+be CopyConstructible.
+
    
 
+
    
+The signature taking InputIterator parameters requires
+CopyConstructible of value_type if the dereferenced
+InputIterator returns an lvalue or const rvalue
+value_type.
+
    
 
+
    
 
+
    
+
+
    unordered_multiset
    
 
-
    
-
    671. precision of hexfloat
    
-
    Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Review
- Submitter: John Salmon Opened: 2007-04-20  Last modified: 2009-07-26
    
-
    View other active issues in [facet.num.put.virtuals].
    
-
    View all other issues in [facet.num.put.virtuals].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
-
    
-I am trying to understand how TR1 supports hex float (%a) output.
-
    
-
    
-As far as I can tell, it does so via the following:
-
    
-
    
-8.15 Additions to header <locale> [tr.c99.locale]
-
    
-
    
-In subclause 22.4.2.2.2 [facet.num.put.virtuals], Table 58 Floating-point conversions, after
-the line:
-floatfield == ios_base::scientific %E
-
    
 
    
-add the two lines:
+Change 23.5.4 [unord.multiset]:
 
    
-
    floatfield == ios_base::fixed | ios_base::scientific && !uppercase %a
-floatfield == ios_base::fixed | ios_base::scientific %A 2
+
+
    class unordered_multiset
+{
+    ...
+    unordered_multiset(const unordered_multiset&);
+    unordered_multiset(unordered_multiset&&);
+    ~unordered_multiset();
+    unordered_multiset& operator=(const unordered_multiset&);
+    unordered_multiset& operator=(unordered_multiset&&);
+    ...
+    // modifiers 
+    iterator insert(const value_type& obj); 
+    iterator insert(value_type&& obj);
+    iterator       insert(const_iterator hint, const value_type& obj);
+    iterator       insert(const_iterator hint, value_type&& obj);
+    ...
+};
+
 
    
+
 
    
-[Note: The additional requirements on print and scan functions, later
-in this clause, ensure that the print functions generate hexadecimal
-floating-point fields with a %a or %A conversion specifier, and that
-the scan functions match hexadecimal floating-point fields with a %g
-conversion specifier.  end note]
-
    
-
    
-Following the thread, in 22.4.2.2.2 [facet.num.put.virtuals], we find:
-
    
-
    
-For conversion from a floating-point type, if (flags & fixed) != 0 or
-if str.precision() > 0, then str.precision() is specified in the
-conversion specification.
+Add to 23.5.4.1 [unord.multiset.cnstr]:
 
    
+
+
    
+
    template <class InputIterator>
+  unordered_multiset(InputIterator f, InputIterator l, 
+                size_type n = implementation-defined, 
+                const hasher& hf = hasher(), 
+                const key_equal& eql = key_equal(), 
+                const allocator_type& a = allocator_type());
+
    
+
+
    
+
+Requires: If the iterator's dereference operator returns an
+lvalue or a const rvalue value_type, then the
+value_type shall be CopyConstructible.
+
+
    
+
    
+
 
    
-This would seem to imply that when floatfield == fixed|scientific, the
-precision of the conversion specifier is to be taken from
-str.precision().  Is this really what's intended?  I sincerely hope
-that I'm either missing something or this is an oversight.  Please
-tell me that the committee did not intend to mandate that hex floats
-(and doubles) should by default be printed as if by %.6a.
+Add new section [unord.multiset.modifiers]:
 
    
 
+
    
+
    iterator insert(const value_type& x);
+iterator insert(value_type&& x);
+iterator       insert(const_iterator hint, const value_type& x);
+iterator       insert(const_iterator hint, value_type&& x);
+template <class InputIterator>
+  void insert(InputIterator first, InputIterator last);
+
    
+
+
    
+
+
    
+Requires: Those signatures taking a const
+value_type& parameter requires the value_type to
+be CopyConstructible.
+
    
+
+
    
+The signature taking InputIterator parameters requires
+CopyConstructible of value_type if the dereferenced
+InputIterator returns an lvalue or const rvalue
+value_type.
+
    
+
+
    
+
+
    
+
+
+
 
    [
-Howard: I think the fundamental issue we overlooked was that with %f,
-%e, %g, the default precision was always 6.  With %a the default
-precision is not 6, it is infinity.  So for the first time, we need to
-distinguish between the default value of precision, and the precision
-value 6.
+Voted to WP in Bellevue.
 ]
    
 
 
 
    [
-2009-07 Frankfurt
+post Bellevue, Pete notes:
 ]
    
 
 
 
    
 
    
-Leave this open for Robert and Daniel to work on.
-
    
-
    
-Straw poll: Disposition?
+Please remind people who are reviewing issues to check that the text
+modifications match the current draft. Issue 676, for example, adds two
+overloads for unordered_map::insert taking a hint. One takes a
+const_iterator and returns a const_iterator, and the other takes an
+iterator and returns an iterator. This was correct at the time the issue
+was written, but was changed in Toronto so there is only one hint
+overload, taking a const_iterator and returning an iterator.
 
    
-
      
-
    • Default is %.6a (i.e. NAD): 2
      • 
-
    • Always %a (no precision): 6
      • 
-
    • precision(-1) == %a: 3
      • 
-
    
 
    
-Daniel and Robert have direction to write up wording for the "always %a" solution.
+This issue is not ready. In addition to the relatively minor signature
+problem I mentioned earlier, it puts requirements in the wrong places.
+Instead of duplicating requirements throughout the template
+specifications, it should put them in the front matter that talks about
+requirements for unordered containers in general. This presentation
+problem is editorial, but I'm not willing to do the extensive rewrite
+that it requires. Please put it back into Open status.
 
    
+
    
 
+
    Rationale:
    
 
    [
-2009-07-15 Robert provided wording.
+San Francisco:
 ]
    
 
-
    
-
-
-
-
    Proposed resolution:
    
-
    
-Change 22.4.2.2.2 [facet.num.put.virtuals], Stage 1, under p5 (near the end
-of Stage 1):
-
    
 
 
    
-For conversion from a floating-point type, str.precision() is specified
-as precision in the conversion specification
-if floatfield != (ios_base::fixed | ios_base::scientific), else no
-precision is specified.
+Solved by
+N2776.
 
    
 
 
 
-
    [
-Kona (2007): Robert volunteers to propose wording.
-]
    
-
-
 
 
 
 
    
-
    676. Moving the unordered containers
    
-
    Section: 23.5 [unord] Status: Open
- Submitter: Howard Hinnant Opened: 2007-05-05  Last modified: 2009-07-28
    
-
    View all other issues in [unord].
    
+
    704. MoveAssignable requirement for container value type overly strict
    
+
    Section: 23.2 [container.requirements] Status: Open
+ Submitter: Howard Hinnant Opened: 2007-05-20  Last modified: 2009-10-20
    
+
    View other active issues in [container.requirements].
    
+
    View all other issues in [container.requirements].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
 
    
-Move semantics are missing from the unordered containers.  The proposed
-resolution below adds move-support consistent with
-N1858
-and the current working draft.
-
    
-
-
    
-The current proposed resolution simply lists the requirements for each function.
-These might better be hoisted into the requirements table for unordered associative containers.
-Futhermore a mild reorganization of the container requirements could well be in order.
-This defect report is purposefully ignoring these larger issues and just focusing
-on getting the unordered containers "moved".
+The move-related changes inadvertently overwrote the intent of 276.
+Issue 276 removed the requirement of CopyAssignable from
+most of the member functions of node-based containers.  But the move-related changes
+unnecessarily introduced the MoveAssignable requirement for those members which used to
+require CopyAssignable.
 
    
 
-
    [
-2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
-]
    
-
-
-
-
-
    Proposed resolution:
    
-
 
    
-Add to 23.5 [unord]:
+We also discussed (c++std-lib-18722) the possibility of dropping MoveAssignable
+from some of the sequence requirements.  Additionally the in-place construction
+work may further reduce requirements.  For purposes of an easy reference, here are the
+minimum sequence requirements as I currently understand them.  Those items in requirements
+table in the working draft which do not appear below have been purposefully omitted for
+brevity as they do not have any requirements of this nature.  Some items which do not
+have any requirements of this nature are included below just to confirm that they were
+not omitted by mistake.
 
    
 
-
    template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>& y); 
-
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>&& y);
-
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>& y);
+
    
 
 
    
+
 *r = o
-
+
 result is not used
-
 
  
 
 
- 
+
+Post: r is not required to be dereferenceable.  r is incrementable.
+
 
 
    
 
 
    
+
 ++r
-
+
 X&
-
 
  
 
+
 &r == &++r
-
 
    
 
 
    
+
 r++
-
+
 convertible to const X&
-
+
 {X tmp = r;
    ++r;
    return tmp;}    
-    		
 
- 
+
+Post: r is dereferenceable, unless otherwise specified. r is not required to be incrementable.
+
 
 
    
 
 
    
 
-*r++ = o
    *r = o, ++r
    *r = o, r++    
+*r++ = o;
     		
 
-result is not used usable
+result is not used
 
 
  
 
 
-Note: only these forms permitted
+
 
 
     
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    
+
+
+
+
+
+
+
    Container Requirements
    X u(a)value_type must be CopyConstructible
    X u(rv)array and containers with a propagate_never allocator require value_type to be MoveConstructible
    a = uSequences require value_type to be CopyConstructible and CopyAssignable.
+                               Associative containers require value_type to be CopyConstructible.
    a = rvarray requires value_type to be MoveAssignable.
+                                Sequences and Associative containers with propagate_never and propagate_on_copy_construction allocators require value_type to be MoveConstructible.
    swap(a,u)array and containers with propagate_never and
+                  propagate_on_copy_construction allocators require value_type to be Swappable.
    
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
+
    
+
    
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>&& y);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Sequence Requirements
    X(n)value_type must be DefaultConstructible
    X(n, t)value_type must be CopyConstructible
    X(i, j)If the iterators return an lvalue the value_type must be CopyConstructible.
+                                 If the iterators return an rvalue the value_type must be MoveConstructible.
    a.insert(p, t)The value_type must be CopyConstructible.
+                                        The sequences vector and deque also require the value_type to be CopyAssignable.
    a.insert(p, rv)The value_type must be MoveConstructible.
+                                        The sequences vector and deque also require the value_type to be MoveAssignable.
    a.insert(p, n, t)The value_type must be CopyConstructible.
+                                        The sequences vector and deque also require the value_type to be CopyAssignable.
    a.insert(p, i, j)If the iterators return an lvalue the value_type must be CopyConstructible.
+                                        The sequences vector and deque also require the value_type to be CopyAssignable when the iterators return an lvalue.
+                                        If the iterators return an rvalue the value_type must be MoveConstructible.
+                                        The sequences vector and deque also require the value_type to be MoveAssignable when the iterators return an rvalue.
    a.erase(p)The sequences vector and deque require the value_type to be MoveAssignable.
    a.erase(q1, q2)The sequences vector and deque require the value_type to be MoveAssignable.
    a.clear()
    a.assign(i, j)If the iterators return an lvalue the value_type must be CopyConstructible and CopyAssignable.
+                                        If the iterators return an rvalue the value_type must be MoveConstructible and MoveAssignable.
    a.assign(n, t)The value_type must be CopyConstructible and CopyAssignable.
    a.resize(n)The value_type must be DefaultConstructible.
+                                     The sequence vector also requires the value_type to be MoveConstructible.
    a.resize(n, t)The value_type must be CopyConstructible.
    
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
+
    
+
    
 
-...
+
+
+
+
+
+
+
+
+
+
+
+
+
    Optional Sequence Requirements
    a.front()
    a.back()
    a.push_front(t)The value_type must be CopyConstructible.
    a.push_front(rv)The value_type must be MoveConstructible.
    a.push_back(t)The value_type must be CopyConstructible.
    a.push_back(rv)The value_type must be MoveConstructible.
    a.pop_front()
    a.pop_back()
    a[n]
    a.at[n]
    
 
-template <class Value, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Value, Hash, Pred, Alloc>& x, 
-            unordered_set<Value, Hash, Pred, Alloc>& y); 
+
    
+
    
 
-template <class Value, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Value, Hash, Pred, Alloc>& x, 
-            unordered_set<Value, Hash, Pred, Alloc>&& y);
+
+
+
+
+
+
+
+
+
+
+
    Associative Container Requirements
    X(i, j)If the iterators return an lvalue the value_type must be CopyConstructible.
+                                 If the iterators return an rvalue the value_type must be MoveConstructible.
    a_uniq.insert(t)The value_type must be CopyConstructible.
    a_uniq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
    a_eq.insert(t)The value_type must be CopyConstructible.
    a_eq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
    a.insert(p, t)The value_type must be CopyConstructible.
    a.insert(p, rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
    a.insert(i, j)If the iterators return an lvalue the value_type must be CopyConstructible.
+                                        If the iterators return an rvalue the key_type and the mapped_type (if it exists) must be MoveConstructible..
    
 
-template <class Value, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Value, Hash, Pred, Alloc>&& x, 
-            unordered_set<Value, Hash, Pred, Alloc>& y);
+
    
+
    
 
-template <class Value, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x, 
-            unordered_multiset<Value, Hash, Pred, Alloc>& y);
+
+
+
+
+
+
+
+
+
+
+
    Unordered Associative Container Requirements
    X(i, j, n, hf, eq)If the iterators return an lvalue the value_type must be CopyConstructible.
+                                 If the iterators return an rvalue the value_type must be MoveConstructible.
    a_uniq.insert(t)The value_type must be CopyConstructible.
    a_uniq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
    a_eq.insert(t)The value_type must be CopyConstructible.
    a_eq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
    a.insert(p, t)The value_type must be CopyConstructible.
    a.insert(p, rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
    a.insert(i, j)If the iterators return an lvalue the value_type must be CopyConstructible.
+                                        If the iterators return an rvalue the key_type and the mapped_type (if it exists) must be MoveConstructible..
    
 
-template <class Value, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x, 
-            unordered_multiset<Value, Hash, Pred, Alloc>&& y);
+
    
+
    
 
-template <class Value, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Value, Hash, Pred, Alloc>&& x, 
-            unordered_multiset<Value, Hash, Pred, Alloc>& y);
-
    + + + + +
    Miscellaneous Requirements
    map[lvalue-key]The key_type must be CopyConstructible. + The mapped_type must be DefaultConstructible and MoveConstructible.
    map[rvalue-key]The key_type must be MoveConstructible. + The mapped_type must be DefaultConstructible and MoveConstructible.
    -

    unordered_map

    +

    [ +Kona (2007): Howard and Alan to update requirements table in issue with emplace signatures. +]

    -

    -Change 23.5.1 [unord.map]: -

    -
    class unordered_map
-{
-    ...
-    unordered_map(const unordered_map&);
-    unordered_map(unordered_map&&);
-    ~unordered_map();
-    unordered_map& operator=(const unordered_map&);
-    unordered_map& operator=(unordered_map&&);
-    ...
-    // modifiers 
-    std::pair<iterator, bool> insert(const value_type& obj); 
-    template <class P> pair<iterator, bool> insert(P&& obj);
-    iterator       insert(iterator hint, const value_type& obj);
-    template <class P> iterator       insert(iterator hint, P&& obj);
-    const_iterator insert(const_iterator hint, const value_type& obj);
-    template <class P> const_iterator insert(const_iterator hint, P&& obj);
-    ...
-    void swap(unordered_map&&);
-    ...
-    mapped_type& operator[](const key_type& k);
-    mapped_type& operator[](key_type&& k);
-    ...
-};
+
    [
+Bellevue: This should be handled as part of the concepts work.
+]
    
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>& y);
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>&& y);
+
    [
+2009-07-20 Reopened by Howard:
+]
    
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>& y);
-
    +

    -Add to 23.5.1.1 [unord.map.cnstr]: +This is one of the issues that was "solved by concepts" and is now no longer solved.

    -
    -
    template <class InputIterator>
-  unordered_map(InputIterator f, InputIterator l, 
-                size_type n = implementation-defined, 
-                const hasher& hf = hasher(), 
-                const key_equal& eql = key_equal(), 
-                const allocator_type& a = allocator_type());
-
    +

    +In a nutshell, concepts adopted the "minimum requirements" philosophy outlined +in the discussion of this issue, and enforced it. My strong suggestion is that +we translate the concepts specification into documentation for the containers. +

    -

    - -Requires: If the iterator's dereference operator returns an -lvalue or a const rvalue pair<key_type, mapped_type>, -then both key_type and mapped_type shall be -CopyConstructible. - -

    -
    +

    +What this means for vendors is that they will have to implement container members +being careful to only use those characteristics of a type that the concepts specification +formally allowed. Note that I am not talking about enable_if'ing +everything. I am simply suggesting that (for example) we tell the vendor he can't call T's +copy constructor or move constructor within the emplace member function, etc. +

    -Add to 23.5.1.2 [unord.map.elem]: +What this means for customers is that they will be able to use types within C++03 +containers which are sometimes not CopyConstructible, and sometimes not even +MoveConstructible, etc.

    +
    -
    +

    [ +2009-10 Santa Cruz: +]

    -
    mapped_type& operator[](const key_type& k);
    -

    ...

    -

    -Requires: key_type shall be CopyConstructible -and mapped_type shall be DefaultConstructible. -

    +Leave open. Howard to provide wording.
    -
    mapped_type& operator[](key_type&& k);
    -
    -

    -Effects: If the unordered_map does not already contain an -element whose key is equivalent to k , inserts the value -std::pair<const key_type, mapped_type>(std::move(k), mapped_type()). -

    -

    -Requires: mapped_type shall be DefaultConstructible. -

    +

    Proposed resolution:

    -

    -Returns: A reference to x.second, where x is the -(unique) element whose key is equivalent to k. -

    -
    -
    +

    Rationale:

    +

    [ +post San Francisco: +]

    -

    -Add new section [unord.map.modifiers]: -

    -
    pair<iterator, bool> insert(const value_type& x);
-template <class P> pair<iterator, bool> insert(P&& x);
-iterator       insert(iterator hint, const value_type& x);
-template <class P> iterator       insert(iterator hint, P&& x);
-const_iterator insert(const_iterator hint, const value_type& x);
-template <class P> const_iterator insert(const_iterator hint, P&& x);
-template <class InputIterator>
-  void insert(InputIterator first, InputIterator last);
-
    +Solved by +N2776. +
    -
    -

    -Requires: Those signatures taking a const value_type& parameter -requires both the key_type and the mapped_type to be -CopyConstructible. -

    -

    -P shall be convertible to value_type. - If P is instantiated as a reference -type, then the argument x is copied from. Otherwise x -is considered to be an rvalue as it is converted to value_type -and inserted into the unordered_map. Specifically, in such -cases CopyConstructible is not required of key_type or -mapped_type unless the conversion from P specifically -requires it (e.g. if P is a tuple<const key_type, -mapped_type>, then key_type must be -CopyConstructible). -

    -

    -The signature taking InputIterator -parameters requires CopyConstructible of both -key_type and mapped_type if the dereferenced -InputIterator returns an lvalue or const rvalue -value_type. -

    -
    - +
    +

    724. DefaultConstructible is not defined

    +

    Section: 20.2.1 [utility.arg.requirements] Status: Open + Submitter: Pablo Halpern Opened: 2007-09-12 Last modified: 2009-10-23

    +

    View other active issues in [utility.arg.requirements].

    +

    View all other issues in [utility.arg.requirements].

    +

    View all issues with Open status.

    +

    Discussion:

    -Add to 23.5.1.3 [unord.map.swap]: +The DefaultConstructible requirement is referenced in +several places in the August 2007 working draft +N2369, +but is not defined anywhere.

    -
    -
    template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>&& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_map<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_map<Key, T, Hash, Pred, Alloc>& y);
-
    -
    +

    [ +Bellevue: +]

    -

    unordered_multimap

    +

    -Change 23.5.2 [unord.multimap]: +Walking into the default/value-initialization mess...

    +

    +Why two lines? Because we need both expressions to be valid. +

    +

    +AJM not sure what the phrase "default constructed" means. This is +unfortunate, as the phrase is already used 24 times in the library! +

    +

    +Example: const int would not accept first line, but will accept the second. +

    +

    +This is an issue that must be solved by concepts, but we might need to solve it independantly first. +

    +

    +It seems that the requirements are the syntax in the proposed first +column is valid, but not clear what semantics we need. +

    +

    +A table where there is no post-condition seems odd, but appears to sum up our position best. +

    +

    +At a minimum an object is declared and is destuctible. +

    +

    +Move to open, as no-one happy to produce wording on the fly. +

    +
    -
    class unordered_multimap
-{
-    ...
-    unordered_multimap(const unordered_multimap&);
-    unordered_multimap(unordered_multimap&&);
-    ~unordered_multimap();
-    unordered_multimap& operator=(const unordered_multimap&);
-    unordered_multimap& operator=(unordered_multimap&&);
-    ...
-    // modifiers 
-    iterator insert(const value_type& obj); 
-    template <class P> iterator insert(P&& obj);
-    iterator       insert(iterator hint, const value_type& obj);
-    template <class P> iterator       insert(iterator hint, P&& obj);
-    const_iterator insert(const_iterator hint, const value_type& obj);
-    template <class P> const_iterator insert(const_iterator hint, P&& obj);
-    ...
-    void swap(unordered_multimap&&);
-    ...
-};
-
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
+
    [
+2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+]
    
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>&& y);
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
-
    +

    [ +2009-08-17 Daniel adds "[defaultconstructible]" to table title. 408 +depends upon this issue. +]

    -

    -Add to 23.5.2.1 [unord.multimap.cnstr]: -

    -
    -
    template <class InputIterator>
-  unordered_multimap(InputIterator f, InputIterator l, 
-                size_type n = implementation-defined, 
-                const hasher& hf = hasher(), 
-                const key_equal& eql = key_equal(), 
-                const allocator_type& a = allocator_type());
-
    +

    [ +2009-08-18 Alisdair adds: +]

    -

    - -Requires: If the iterator's dereference operator returns an -lvalue or a const rvalue pair<key_type, mapped_type>, -then both key_type and mapped_type shall be -CopyConstructible. - -

    -
    +

    -Add new section [unord.multimap.modifiers]: +Looking at the proposed table in this issue, it really needs two rows:

    -
    iterator insert(const value_type& x);
-template <class P> iterator       insert(P&& x);
-iterator       insert(iterator hint, const value_type& x);
-template <class P> iterator       insert(iterator hint, P&& x);
-const_iterator insert(const_iterator hint, const value_type& x);
-template <class P> const_iterator insert(const_iterator hint, P&& x);
-template <class InputIterator>
-  void insert(InputIterator first, InputIterator last);
-
    - -
    -

    -Requires: Those signatures taking a const value_type& parameter -requires both the key_type and the mapped_type to be -CopyConstructible. -

    - -

    -P shall be convertible to value_type. - If P is instantiated as a reference -type, then the argument x is copied from. Otherwise x -is considered to be an rvalue as it is converted to value_type -and inserted into the unordered_multimap. Specifically, in such -cases CopyConstructible is not required of key_type or -mapped_type unless the conversion from P specifically -requires it (e.g. if P is a tuple<const key_type, -mapped_type>, then key_type must be -CopyConstructible). -

    + + + + + -

    -The signature taking InputIterator -parameters requires CopyConstructible of both -key_type and mapped_type if the dereferenced -InputIterator returns an lvalue or const rvalue -value_type. -

    - + + + + + + +
    Table 33: DefaultConstructible requirements [defaultconstructible]
    expressionpost-condition
    T t;t is default-initialized.
    T{}Object of type T is value-initialized.

    -Add to 23.5.2.2 [unord.multimap.swap]: +Note I am using the new brace-initialization syntax that is unambiguous +in all use cases (no most vexing parse.)

    - -
    -
    template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>&& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
-
    -

    unordered_set

    +

    [ +2009-10-03 Daniel adds: +]

    + +

    -Change 23.5.3 [unord.set]: +The suggested definition T{} describing it as +value-initialization is wrong, because it belongs to list-initialization +which would - as the current rules are - always prefer a +initializer-list constructor over a default-constructor. I don't +consider this as an appropriate definition of +DefaultConstructible. My primary suggestion is to ask core, +whether the special case T{} (which also easily leads to +ambiguity situations for more than one initializer-list in a class) +would always prefer a default-constructor - if any - before considering +an initializer-list constructor or to provide another syntax form to +prefer value-initialization over list-initialization. If that fails I +would fall back to suggest to use the expression T() instead of +T{} with all it's disadvantages for the meaning of the +expression

    -
    class unordered_set
-{
-    ...
-    unordered_set(const unordered_set&);
-    unordered_set(unordered_set&&);
-    ~unordered_set();
-    unordered_set& operator=(const unordered_set&);
-    unordered_set& operator=(unordered_set&&);
-    ...
-    // modifiers 
-    std::pair<iterator, bool> insert(const value_type& obj); 
-    pair<iterator, bool> insert(value_type&& obj);
-    iterator       insert(iterator hint, const value_type& obj);
-    iterator       insert(iterator hint, value_type&& obj);
-    const_iterator insert(const_iterator hint, const value_type& obj);
-    const_iterator insert(const_iterator hint, value_type&& obj);
-    ...
-    void swap(unordered_set&&);
-    ...
-};
-
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_set<Key, T, Hash, Pred, Alloc>& y);
-
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_set<Key, T, Hash, Pred, Alloc>&& y);
-
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_set<Key, T, Hash, Pred, Alloc>& y);
+
    T t();
 
    
+
    -

    -Add to 23.5.3.1 [unord.set.cnstr]: -

    +

    [ +2009-10 Santa Cruz: +]

    -
    -
    template <class InputIterator>
-  unordered_set(InputIterator f, InputIterator l, 
-                size_type n = implementation-defined, 
-                const hasher& hf = hasher(), 
-                const key_equal& eql = key_equal(), 
-                const allocator_type& a = allocator_type());
-
    -

    - -Requires: If the iterator's dereference operator returns an -lvalue or a const rvalue value_type, then the -value_type shall be CopyConstructible. - -

    +
    +Leave Open. Core is looking to make Alisdair's proposed +resolution correct.
    + + +

    Proposed resolution:

    -Add new section [unord.set.modifiers]: +In section 20.2.1 [utility.arg.requirements], before table 33, add the +following table:

    -
    -
    pair<iterator, bool> insert(const value_type& x);
-pair<iterator, bool> insert(value_type&& x);
-iterator       insert(iterator hint, const value_type& x);
-iterator       insert(iterator hint, value_type&& x);
-const_iterator insert(const_iterator hint, const value_type& x);
-const_iterator insert(const_iterator hint, value_type&& x);
-template <class InputIterator>
-  void insert(InputIterator first, InputIterator last);
-
    +

    Table 33: DefaultConstructible requirements [defaultconstructible]

    -
    +
    -

    -Requires: Those signatures taking a const -value_type& parameter requires the value_type to -be CopyConstructible. -

    + + + + + + + + + +
    +

    expression

    +     		+

    post-condition

    +
    +

    T + t;
    + T()

    +     		+

    T + is default constructed.

    +
    -

    -The signature taking InputIterator parameters requires -CopyConstructible of value_type if the dereferenced -InputIterator returns an lvalue or const rvalue -value_type. -

    +
    -
    -
    -

    -Add to 23.5.3.2 [unord.set.swap]: -

    +

    Rationale:

    +

    [ +San Francisco: +]

    -
    template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_set<Key, T, Hash, Pred, Alloc>& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_set<Key, T, Hash, Pred, Alloc>&& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_set<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_set<Key, T, Hash, Pred, Alloc>& y);
-
    +We believe concepts will solve this problem +(N2774).
    -

    unordered_multiset

    - -

    -Change 23.5.4 [unord.multiset]: -

    - -
    class unordered_multiset
-{
-    ...
-    unordered_multiset(const unordered_multiset&);
-    unordered_multiset(unordered_multiset&&);
-    ~unordered_multiset();
-    unordered_multiset& operator=(const unordered_multiset&);
-    unordered_multiset& operator=(unordered_multiset&&);
-    ...
-    // modifiers 
-    iterator insert(const value_type& obj); 
-    iterator insert(value_type&& obj);
-    iterator       insert(iterator hint, const value_type& obj);
-    iterator       insert(iterator hint, value_type&& obj);
-    const_iterator insert(const_iterator hint, const value_type& obj);
-    const_iterator insert(const_iterator hint, value_type&& obj);
-    ...
-    void swap(unordered_multiset&&);
-    ...
-};
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multiset<Key, T, Hash, Pred, Alloc>& y);
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multiset<Key, T, Hash, Pred, Alloc>&& y);
 
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_multiset<Key, T, Hash, Pred, Alloc>& y);
-
    +
    +

    726. Missing regex_replace() overloads

    +

    Section: 28.11.4 [re.alg.replace] Status: Open + Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-10-23

    +

    View other active issues in [re.alg.replace].

    +

    View all other issues in [re.alg.replace].

    +

    View all issues with Open status.

    +

    Discussion:

    -Add to 23.5.4.1 [unord.multiset.cnstr]: +Two overloads of regex_replace() are currently provided:

    -
    -
    template <class InputIterator>
-  unordered_multiset(InputIterator f, InputIterator l, 
-                size_type n = implementation-defined, 
-                const hasher& hf = hasher(), 
-                const key_equal& eql = key_equal(), 
-                const allocator_type& a = allocator_type());
-
    - -

    - -Requires: If the iterator's dereference operator returns an -lvalue or a const rvalue value_type, then the -value_type shall be CopyConstructible. - -

    -
    +
    template <class OutputIterator, class BidirectionalIterator, 
+    class traits, class charT> 
+  OutputIterator 
+  regex_replace(OutputIterator out, 
+                BidirectionalIterator first, BidirectionalIterator last, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+ 
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const basic_string<charT>& s, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
    -

    -Add new section [unord.multiset.modifiers]: -

    +
      +
    1. Overloads taking const charT * are provided for regex_match() and +regex_search(), but not regex_replace(). This is inconsistent.
      2. +
    2. +

      The absence of const charT * overloads prevents ordinary-looking code from compiling, such as:

      -
      -
      iterator insert(const value_type& x);
-iterator insert(value_type&& x);
-iterator       insert(iterator hint, const value_type& x);
-iterator       insert(iterator hint, value_type&& x);
-const_iterator insert(const_iterator hint, const value_type& x);
-const_iterator insert(const_iterator hint, value_type&& x);
-template <class InputIterator>
-  void insert(InputIterator first, InputIterator last);
-
      +
      const string s("kitten");
+const regex r("en");
+cout << regex_replace(s, r, "y") << endl;
+
      -
      +

      +The compiler error message will be something like "could not deduce +template argument for 'const std::basic_string<_Elem> &' from 'const +char[1]'". +

      -

      -Requires: Those signatures taking a const -value_type& parameter requires the value_type to -be CopyConstructible. -

      +

      +Users expect that anything taking a basic_string<charT> can also take a +const charT *. In their own code, when they write a function taking +std::string (or std::wstring), they can pass a const char * (or const +wchar_t *), thanks to basic_string's implicit constructor. Because the +regex algorithms are templated on charT, they can't rely on +basic_string's implicit constructor (as the compiler error message +indicates, template argument deduction fails first). +

      -

      -The signature taking InputIterator parameters requires -CopyConstructible of value_type if the dereferenced -InputIterator returns an lvalue or const rvalue -value_type. -

      +

      +If a user figures out what the compiler error message means, workarounds +are available - but they are all verbose. Explicit template arguments +could be given to regex_replace(), allowing basic_string's implicit +constructor to be invoked - but charT is the last template argument, not +the first, so this would be extremely verbose. Therefore, constructing +a basic_string from each C string is the simplest workaround. +

      +
      3. -
    +
  • +There is an efficiency consideration: constructing basic_strings can +impose performance costs that could be avoided by a library +implementation taking C strings and dealing with them directly. +(Currently, for replacement sources, C strings can be converted into +iterator pairs at the cost of verbosity, but for format strings, there +is no way to avoid constructing a basic_string.) +
    • + -
    +

    [ +Sophia Antipolis: +]

    -

    -Add to 23.5.4.2 [unord.multiset.swap]: -

    -
    template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multiset<Key, T, Hash, Pred, Alloc>& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>& x, 
-            unordered_multiset<Key, T, Hash, Pred, Alloc>&& y);
-template <class Key, class T, class Hash, class Pred, class Alloc> 
-  void swap(unordered_multiset<Key, T, Hash, Pred, Alloc>&& x, 
-            unordered_multiset<Key, T, Hash, Pred, Alloc>& y);
-
    +We note that Boost already has these overloads. However, the proposed +wording is provided only for 28.11.4 [re.alg.replace]; wording is needed for the synopsis +as well. We also note that this has impact on match_results::format, +which may require further overloads.
    - -

    [ -Voted to WP in Bellevue. +2009-07 Frankfurt: ]

    +
    +Daniel to tweak for us. +
    +

    [ -post Bellevue, Pete notes: +2009-07-25 Daniel tweaks both this issue and 727. ]

    -Please remind people who are reviewing issues to check that the text -modifications match the current draft. Issue 676, for example, adds two -overloads for unordered_map::insert taking a hint. One takes a -const_iterator and returns a const_iterator, and the other takes an -iterator and returns an iterator. This was correct at the time the issue -was written, but was changed in Toronto so there is only one hint -overload, taking a const_iterator and returning an iterator. -

    -

    -This issue is not ready. In addition to the relatively minor signature -problem I mentioned earlier, it puts requirements in the wrong places. -Instead of duplicating requirements throughout the template -specifications, it should put them in the front matter that talks about -requirements for unordered containers in general. This presentation -problem is editorial, but I'm not willing to do the extensive rewrite -that it requires. Please put it back into Open status. +This is solved by the proposed resolution of 727.

    -

    Rationale:

    [ -San Francisco: +2009-10 Santa Cruz: ]

    -Solved by -N2776. +Leave Open. Though we believe this is solved by the proposed resolution +to 727. +
    + + + +

    Proposed resolution:

    + +

    +Provide additional overloads for regex_replace(): one additional +overload of the iterator-based form (taking const charT* fmt), and three +additional overloads of the convenience form (one taking const charT* +str, another taking const charT* fmt, and the third taking both const +charT* str and const charT* fmt). 28.11.4 [re.alg.replace]: +

    + +
    +
    template <class OutputIterator, class BidirectionalIterator, 
+    class traits, class charT> 
+  OutputIterator 
+  regex_replace(OutputIterator out, 
+                BidirectionalIterator first, BidirectionalIterator last, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class OutputIterator, class BidirectionalIterator, 
+    class traits, class charT> 
+  OutputIterator 
+  regex_replace(OutputIterator out, 
+                BidirectionalIterator first, BidirectionalIterator last, 
+                const basic_regex<charT, traits>& e, 
+                const charT* fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
    +

    ...

    +
    template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const basic_string<charT>& s, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const basic_string<charT>& s, 
+                const basic_regex<charT, traits>& e, 
+                const charT* fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const charT* s, 
+                const basic_regex<charT, traits>& e, 
+                const basic_string<charT>& fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
+template <class traits, class charT> 
+  basic_string<charT> 
+  regex_replace(const charT* s, 
+                const basic_regex<charT, traits>& e, 
+                const charT* fmt, 
+                regex_constants::match_flag_type flags = 
+                  regex_constants::match_default);
+
    @@ -6747,43 +5098,28 @@ Solved by
    -

    696. istream::operator>>(int&) broken

    -

    Section: 27.7.1.2.2 [istream.formatted.arithmetic] Status: Ready - Submitter: Martin Sebor Opened: 2007-06-23 Last modified: 2009-07-15

    -

    View all other issues in [istream.formatted.arithmetic].

    -

    View all issues with Ready status.

    +

    727. regex_replace() doesn't accept basic_strings with custom traits and allocators

    +

    Section: 28.11.4 [re.alg.replace] Status: Review + Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-10-23

    +

    View other active issues in [re.alg.replace].

    +

    View all other issues in [re.alg.replace].

    +

    View all issues with Review status.

    Discussion:

    -From message c++std-lib-17897: -

    -

    -The code shown in 27.7.1.2.2 [istream.formatted.arithmetic] as the "as if" -implementation of the two arithmetic extractors that don't have a -corresponding num_get interface (i.e., the -short and int overloads) is subtly buggy in -how it deals with EOF, overflow, and other similar -conditions (in addition to containing a few typos). -

    -

    -One problem is that if num_get::get() reaches the EOF -after reading in an otherwise valid value that exceeds the limits of -the narrower type (but not LONG_MIN or -LONG_MAX), it will set err to -eofbit. Because of the if condition testing for -(err == 0), the extractor won't set -failbit (and presumably, return a bogus value to the -caller). +regex_match() and regex_search() take const basic_string<charT, ST, +SA>&. regex_replace() takes const basic_string<charT>&. This prevents +regex_replace() from accepting basic_strings with custom traits and +allocators.

    +

    -Another problem with the code is that it never actually sets the -argument to the extracted value. It can't happen after the call to -setstate() since the function may throw, so we need to -show when and how it's done (we can't just punt as say: "it happens -afterwards"). However, it turns out that showing how it's done isn't -quite so easy since the argument is normally left unchanged by the -facet on error except when the error is due to a misplaced thousands -separator, which causes failbit to be set but doesn't -prevent the facet from storing the value. +Overloads of regex_replace() taking basic_string should be additionally +templated on class ST, class SA and take const basic_string<charT, ST, +SA>&. Consistency with regex_match() and regex_search() would place +class ST, class SA as the first template arguments; compatibility with +existing code using TR1 and giving explicit template arguments to +regex_replace() would place class ST, class SA as the last template +arguments.

    [ @@ -6792,369 +5128,431 @@ Batavia (2009-05):

    -We believe this part of the Standard has been recently adjusted -and that this issue was addressed during that rewrite. +Bill comments, "We need to look at the depth of this change."

    -Move to NAD. +Pete remarks that we are here dealing with a convenience function +that saves a user from calling the iterato-based overload. +

    +

    +Move to Open.

    [ -2009-05-28 Howard adds: +2009-07 Frankfurt: ]

    -

    -I've moved this issue from Tentatively NAD to Open. -

    +Howard to ask Stephan Lavavej to provide wording. +
    -

    -The current wording of -N2857 -in 22.4.2.1.2 [facet.num.get.virtuals] p3, stage 3 appears to indicate that -in parsing arithmetic types, the value is always set, but sometimes in addition -to setting failbit. -

    +

    [ +2009-07-17 Stephan provided wording. +]

    -
      -
    • -If there is a range error, the value is set to min or max, else -
      • -
    • -if there is a conversion error, the value is set to 0, else -
      • -
    • -if there is a grouping error, the value is set to whatever it would be if grouping were ignored, else -
      • -
    • -the value is set to its error-free result. -
      • -
    -

    -However there is a contradictory sentence in 22.4.2.1.2 [facet.num.get.virtuals] p1. -

    +

    [ +2009-07-25 Daniel tweaks both this issue and 726. +]

    + + +
    +

    +One relevant part of the proposed resolution below suggests +to add a new overload of the format member function in the +match_results class template that accepts two character pointers +defining the begin and end of a format range. A more general +approach could have proposed a pair of iterators instead, but +the used pair of char pointers reflects existing practice. If the +committee strongly favors an iterator-based signature, this +could be simply changed. I think that the minimum requirement +should be a BidirectionalIterator, but current implementations +take advantage (at least partially) of the RandomAccessIterator +sub interface of the char pointers. +

    + +

    Suggested Resolution:

    + +

    [Moved into the proposed resloution]

    + -

    -27.7.1.2.2 [istream.formatted.arithmetic] should mimic the behavior of 22.4.2.1.2 [facet.num.get.virtuals] -(whatever we decide that behavior is) for -int and short, and currently does not. I believe that the -correct code fragment should look like: -

    -
    typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
-iostate err = ios_base::goodbit;
-long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
-if (lval < numeric_limits<int>::min())
-{
-  err |= ios_base::failbit;
-  val = numeric_limits<int>::min();
-}
-else if (lval > numeric_limits<int>::max())
-{
-  err |= ios_base::failbit;
-  val = numeric_limits<int>::max();
-}
-else
-  val = static_cast<int>(lval);
-setstate(err);
-

    [ -2009-07 Frankfurt +2009-07-30 Stephan agrees with Daniel's wording. Howard places Daniel's wording +in the Proposed Resolution. +]

    + + +

    [ +2009-10 Santa Cruz: ]

    -Move to Ready. +Move to Review. Chair is anxious to move this to Ready in Pittsburgh.

    Proposed resolution:

    + +
      +

    1. -Change 22.4.2.1.2 [facet.num.get.virtuals], p1: +Change 28.4 [re.syn] as indicated:

      -
      --1- Effects: Reads characters from in, interpreting them -according to str.flags(), use_facet<ctype<charT> ->(loc), and use_facet< numpunct<charT> ->(loc), where loc is str.getloc(). If an error -occurs, val is unchanged; otherwise it is set to the resulting value. -
      +
      // 28.11.4, function template regex_replace:
+template <class OutputIterator, class BidirectionalIterator,
+          class traits, class charT, class ST, class SA>
+  OutputIterator
+  regex_replace(OutputIterator out,
+                BidirectionalIterator first, BidirectionalIterator last,
+                const basic_regex<charT, traits>& e,
+                const basic_string<charT, ST, SA>& fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
+
+template <class OutputIterator, class BidirectionalIterator,
+          class traits, class charT>
+  OutputIterator
+  regex_replace(OutputIterator out,
+                BidirectionalIterator first, BidirectionalIterator last,
+                const basic_regex<charT, traits>& e,
+                const charT* fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
+
+template <class traits, class charT, class ST, class SA,
+          class FST, class FSA>
+  basic_string<charT, ST, SA>
+  regex_replace(const basic_string<charT, ST, SA>& s,
+                const basic_regex<charT, traits>& e,
+                const basic_string<charT, FST, FSA>& fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
+
+template <class traits, class charT, class ST, class SA>
+  basic_string<charT, ST, SA>
+  regex_replace(const basic_string<charT, ST, SA>& s,
+                const basic_regex<charT, traits>& e,
+                const charT* fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
+
+
+template <class traits, class charT, class ST, class SA>
+  basic_string<charT>
+  regex_replace(const charT* s,
+                const basic_regex<charT, traits>& e,
+                const basic_string<charT, ST, SA>& fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
+
+
+template <class traits, class charT>
+  basic_string<charT>
+  regex_replace(const charT* s,
+                const basic_regex<charT, traits>& e,
+                const charT* fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
+
      +
      2. +

    2. -Change 27.7.1.2.2 [istream.formatted.arithmetic], p2 and p3: +Change 28.10 [re.results]/3, class template match_results as +indicated:

      -
      -
      operator>>(short& val);
-
      -
      +
      
+template <class OutputIter>
+  OutputIter
+  format(OutputIter out,
+         const char_type* fmt_first, const char_type* fmt_last,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
+
+
+template <class OutputIter, class ST, class SA>
+  OutputIter
+  format(OutputIter out,
+         const string_typebasic_string<char_type, ST, SA>& fmt,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
+
+template <class ST, class SA>
+  string_typebasic_string<char_type, ST, SA>
+  format(const string_typebasic_string<char_type, ST, SA>& fmt,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
+
+
+string_type
+format(const char_type* fmt,
+       regex_constants::match_flag_type flags =
+         regex_constants::format_default) const;
+
+
      +
      3. + +

    3. --2- The conversion occurs as if performed by the following code fragment (using the same notation as for -the preceding code fragment): +Insert at the very beginning of 28.10.4 [re.results.form] the following:

      -
      typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
-iostate err = iostate_base::goodbit;
-long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
-if (err != 0)
-  ;
-else if (lval < numeric_limits<short>::min()
-  || numeric_limits<short>::max() < lval)
-     err = ios_base::failbit;
-if (lval < numeric_limits<short>::min())
-{
-  err |= ios_base::failbit;
-  val = numeric_limits<short>::min();
-}
-else if (lval > numeric_limits<short>::max())
-{
-  err |= ios_base::failbit;
-  val = numeric_limits<short>::max();
-}
-else
-  val = static_cast<short>(lval);
-setstate(err);
-
      +
      
+template <class OutputIter>
+  OutputIter
+  format(OutputIter out,
+         const char_type* fmt_first, const char_type* fmt_last,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
+
+
      +
      + +

      +1 Requires: The type OutputIter shall satisfy the requirements for an +Output Iterator (24.2.2 [output.iterators]). +

      + +

      +2 Effects: Copies the character sequence [fmt_first,fmt_last) to +OutputIter out. Replaces each +format specifier or escape sequence in the copied range with either +the character(s) it represents +or the sequence of characters within *this to which it refers. The +bitmasks specified in flags +determines what format specifiers and escape sequences are recognized. +

      +

      +3 Returns: out. +

      +
      +
      4. + +
    4. +

      +Change 28.10.4 [re.results.form], before p. 1 until p. 3 (according to +previous numbering) +as indicated: +

      -
      operator>>(int& val);
+
      template <class OutputIter, class ST, class SA>
+  OutputIter
+  format(OutputIter out,
+         const string_typebasic_string<char_type, ST, SA>& fmt,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
 
      
+
 
      
 
      
--3- The conversion occurs as if performed by the following code fragment (using the same notation as for 
-the preceding code fragment):
+Requires: The type OutputIter shall satisfy the requirements for
+an Output Iterator (24.2.3).
 
      
 
-
      typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
-iostate err = iostate_base::goodbit;
-long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
-if (err != 0)
-  ;
-else if (lval < numeric_limits<int>::min()
-  || numeric_limits<int>::max() < lval)
-     err = ios_base::failbit;
-if (lval < numeric_limits<int>::min())
-{
-  err |= ios_base::failbit;
-  val = numeric_limits<int>::min();
-}
-else if (lval > numeric_limits<int>::max())
-{
-  err |= ios_base::failbit;
-  val = numeric_limits<int>::max();
-}
-else
-  val = static_cast<int>(lval);
-setstate(err);
-
      
+
      
+Effects: Copies the character sequence [fmt.begin(),fmt.end()) to
+OutputIter out. Replaces each
+format specifier or escape sequence in fmt with either the
+character(s) it represents or the sequence of
+characters within *this to which it refers. The bitmasks specified in
+flags determines what format
+specifiers and escape sequences are recognized.
+
      
 
+
      
+Returns: outformat(out, fmt.data(), fmt.data() +
+fmt.size(), flags).
+
      
 
      
-
 
      
+
      5. +
    5. +

      +Change 28.10.4 [re.results.form], before p. 4 until p. 4 (according to +previous numbering) as indicated: +

      +
      template <class ST, class SA>
+  string_typebasic_string<char_type, ST, SA>
+  format(const string_typebasic_string<char_type, ST, SA>& fmt,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
+
      +
      +

      +Effects: Returns a copy of the string fmt. Replaces each format +specifier or escape sequence +in fmt with either the character(s) it represents or the sequence of +characters within *this to which +it refers. The bitmasks specified in flags determines what format +specifiers and escape sequences are +recognized. Constructs an empty string result of type +basic_string<char_type, ST, SA>, +and calls format(back_inserter(result), fmt, flags). +

      - -
      -

      704. MoveAssignable requirement for container value type overly strict

      -

      Section: 23.2 [container.requirements] Status: Open - Submitter: Howard Hinnant Opened: 2007-05-20 Last modified: 2009-07-20

      -

      View other active issues in [container.requirements].

      -

      View all other issues in [container.requirements].

      -

      View all issues with Open status.

      -

      Discussion:

      -The move-related changes inadvertently overwrote the intent of 276. -Issue 276 removed the requirement of CopyAssignable from -most of the member functions of node-based containers. But the move-related changes -unnecessarily introduced the MoveAssignable requirement for those members which used to -require CopyAssignable. +Returns: result

      +
      +
      +
      6. +

    6. -We also discussed (c++std-lib-18722) the possibility of dropping MoveAssignable -from some of the sequence requirements. Additionally the in-place construction -work may further reduce requirements. For purposes of an easy reference, here are the -minimum sequence requirements as I currently understand them. Those items in requirements -table in the working draft which do not appear below have been purposefully omitted for -brevity as they do not have any requirements of this nature. Some items which do not -have any requirements of this nature are included below just to confirm that they were -not omitted by mistake. +At the end of 28.10.4 [re.results.form] insert as indicated:

      - - - - - - - -
      Container Requirements
      X u(a)value_type must be CopyConstructible
      X u(rv)array and containers with a propagate_never allocator require value_type to be MoveConstructible
      a = uSequences require value_type to be CopyConstructible and CopyAssignable. - Associative containers require value_type to be CopyConstructible.
      a = rvarray requires value_type to be MoveAssignable. - Sequences and Associative containers with propagate_never and propagate_on_copy_construction allocators require value_type to be MoveConstructible.
      swap(a,u)array and containers with propagate_never and - propagate_on_copy_construction allocators require value_type to be Swappable.
      +
      
+string_type
+  format(const char_type* fmt,
+         regex_constants::match_flag_type flags =
+           regex_constants::format_default) const;
+
      +

      +Effects: Constructs an empty string result of type string_type, and calls +format(back_inserter(result), fmt, fmt + +char_traits<char_type>::length(fmt), flags).

      - - - - - - - - - - - - - - - - - -
      Sequence Requirements
      X(n)value_type must be DefaultConstructible
      X(n, t)value_type must be CopyConstructible
      X(i, j)If the iterators return an lvalue the value_type must be CopyConstructible. - If the iterators return an rvalue the value_type must be MoveConstructible.
      a.insert(p, t)The value_type must be CopyConstructible. - The sequences vector and deque also require the value_type to be CopyAssignable.
      a.insert(p, rv)The value_type must be MoveConstructible. - The sequences vector and deque also require the value_type to be MoveAssignable.
      a.insert(p, n, t)The value_type must be CopyConstructible. - The sequences vector and deque also require the value_type to be CopyAssignable.
      a.insert(p, i, j)If the iterators return an lvalue the value_type must be CopyConstructible. - The sequences vector and deque also require the value_type to be CopyAssignable when the iterators return an lvalue. - If the iterators return an rvalue the value_type must be MoveConstructible. - The sequences vector and deque also require the value_type to be MoveAssignable when the iterators return an rvalue.
      a.erase(p)The sequences vector and deque require the value_type to be MoveAssignable.
      a.erase(q1, q2)The sequences vector and deque require the value_type to be MoveAssignable.
      a.clear()
      a.assign(i, j)If the iterators return an lvalue the value_type must be CopyConstructible and CopyAssignable. - If the iterators return an rvalue the value_type must be MoveConstructible and MoveAssignable.
      a.assign(n, t)The value_type must be CopyConstructible and CopyAssignable.
      a.resize(n)The value_type must be DefaultConstructible. - The sequence vector also requires the value_type to be MoveConstructible.
      a.resize(n, t)The value_type must be CopyConstructible.
      -

      +Returns: result

      +
      +
      - - - - - - - - - - - - -
      Optional Sequence Requirements
      a.front()
      a.back()
      a.push_front(t)The value_type must be CopyConstructible.
      a.push_front(rv)The value_type must be MoveConstructible.
      a.push_back(t)The value_type must be CopyConstructible.
      a.push_back(rv)The value_type must be MoveConstructible.
      a.pop_front()
      a.pop_back()
      a[n]
      a.at[n]
      +
      7. +

    7. +Change 28.11.4 [re.alg.replace] before p. 1 as indicated:

      - - - - - - - - - - -
      Associative Container Requirements
      X(i, j)If the iterators return an lvalue the value_type must be CopyConstructible. - If the iterators return an rvalue the value_type must be MoveConstructible.
      a_uniq.insert(t)The value_type must be CopyConstructible.
      a_uniq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
      a_eq.insert(t)The value_type must be CopyConstructible.
      a_eq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
      a.insert(p, t)The value_type must be CopyConstructible.
      a.insert(p, rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
      a.insert(i, j)If the iterators return an lvalue the value_type must be CopyConstructible. - If the iterators return an rvalue the key_type and the mapped_type (if it exists) must be MoveConstructible..
      +
      template <class OutputIterator, class BidirectionalIterator,
+          class traits, class charT, class ST, class SA>
+  OutputIterator
+  regex_replace(OutputIterator out,
+                BidirectionalIterator first, BidirectionalIterator last,
+                const basic_regex<charT, traits>& e,
+                const basic_string<charT, ST, SA>& fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
 
-
      
-
      
+
+template <class OutputIterator, class BidirectionalIterator,
+          class traits, class charT>
+  OutputIterator
+  regex_replace(OutputIterator out,
+                BidirectionalIterator first, BidirectionalIterator last,
+                const basic_regex<charT, traits>& e,
+                const charT* fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
      - - - - - - - - - - -
      Unordered Associative Container Requirements
      X(i, j, n, hf, eq)If the iterators return an lvalue the value_type must be CopyConstructible. - If the iterators return an rvalue the value_type must be MoveConstructible.
      a_uniq.insert(t)The value_type must be CopyConstructible.
      a_uniq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
      a_eq.insert(t)The value_type must be CopyConstructible.
      a_eq.insert(rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
      a.insert(p, t)The value_type must be CopyConstructible.
      a.insert(p, rv)The key_type and the mapped_type (if it exists) must be MoveConstructible.
      a.insert(i, j)If the iterators return an lvalue the value_type must be CopyConstructible. - If the iterators return an rvalue the key_type and the mapped_type (if it exists) must be MoveConstructible..
      +
      +Effects: [..]. If any matches are found then, for each such match, if !(flags & + regex_constants::format_no_copy) calls std::copy(m.prefix().first, +m.prefix().second, + out), and then calls m.format(out, fmt, flags) for the first +form of the function + and m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags) +for the second + form. [..]. +
      +
      +
      8. +

    8. +Change 28.11.4 [re.alg.replace] before p. 3 as indicated:

      - - - - -
      Miscellaneous Requirements
      map[lvalue-key]The key_type must be CopyConstructible. - The mapped_type must be DefaultConstructible and MoveConstructible.
      map[rvalue-key]The key_type must be MoveConstructible. - The mapped_type must be DefaultConstructible and MoveConstructible.
      - -

      [ -Kona (2007): Howard and Alan to update requirements table in issue with emplace signatures. -]

      - - -

      [ -Bellevue: This should be handled as part of the concepts work. -]

      - - -

      [ -2009-07-20 Reopened by Howard: -]

      +
      template <class traits, class charT, class ST, class SA,
+          class FST, class FSA>
+  basic_string<charT, ST, SA>
+  regex_replace(const basic_string<charT, ST, SA>& s,
+                const basic_regex<charT, traits>& e,
+                const basic_string<charT, FST, FSA>& fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
 
+
+template <class traits, class charT, class ST, class SA>
+  basic_string<charT, ST, SA>
+  regex_replace(const basic_string<charT, ST, SA>& s,
+                const basic_regex<charT, traits>& e,
+                const charT* fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
      -

      -This is one of the issues that was "solved by concepts" and is now no longer solved. -

      - -

      -In a nutshell, concepts adopted the "minimum requirements" philosophy outlined -in the discussion of this issue, and enforced it. My strong suggestion is that -we translate the concepts specification into documentation for the containers. -

      - -

      -What this means for vendors is that they will have to implement container members -being careful to only use those characteristics of a type that the concepts specification -formally allowed. Note that I am not talking about enable_if'ing -everything. I am simply suggesting that (for example) we tell the vendor he can't call T's -copy constructor or move constructor within the emplace member function, etc. -

      +Effects: Constructs an empty string result of type basic_string<charT, +ST, SA>, calls regex_replace(back_inserter(result), s.begin(), s.end(), +e, fmt, flags), and then returns result. +
      +
      +
      9. +

    9. -What this means for customers is that they will be able to use types within C++03 -containers which are sometimes not CopyConstructible, and sometimes not even -MoveConstructible, etc. +At the end of 28.11.4 [re.alg.replace] add the following new prototype description:

      -
    - - - -

    Proposed resolution:

    - +
    
+template <class traits, class charT, class ST, class SA>
+  basic_string<charT>
+  regex_replace(const charT* s,
+                const basic_regex<charT, traits>& e,
+                const basic_string<charT, ST, SA>& fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
 
-
    Rationale:
    
-
    [
-post San Francisco:
-]
    
-
+
+template <class traits, class charT>
+  basic_string<charT>
+  regex_replace(const charT* s,
+                const basic_regex<charT, traits>& e,
+                const charT* fmt,
+                regex_constants::match_flag_type flags =
+                  regex_constants::match_default);
+
    -Solved by -N2776. + +Effects: Constructs an empty string result of type basic_string<charT>, +calls regex_replace(back_inserter(result), s, s + +char_traits<charT>::length(s), +e, fmt, flags), and then returns result. +
    +
    +
    • + + + @@ -7162,1288 +5560,1382 @@ Solved by
    -

    711. Contradiction in empty shared_ptr

    -

    Section: 20.8.10.2.5 [util.smartptr.shared.obs] Status: Ready - Submitter: Peter Dimov Opened: 2007-08-24 Last modified: 2009-07-17

    -

    View all other issues in [util.smartptr.shared.obs].

    -

    View all issues with Ready status.

    +

    742. Enabling swap for proxy iterators

    +

    Section: 20.2.1 [utility.arg.requirements] Status: Open + Submitter: Howard Hinnant Opened: 2007-10-10 Last modified: 2009-11-08

    +

    View other active issues in [utility.arg.requirements].

    +

    View all other issues in [utility.arg.requirements].

    +

    View all issues with Open status.

    Discussion:

    -A discussion on -comp.std.c++ -has identified a contradiction in the shared_ptr specification. -The note: +This issue was split from 672. 672 now just +deals with changing the requirements of T in the Swappable +requirement from CopyConstructible and CopyAssignable to +MoveConstructible and MoveAssignable.

    -

    -[ Note: this constructor allows creation of an empty shared_ptr instance with a non-NULL stored pointer. --end note ] -

    -

    -after the aliasing constructor +This issue seeks to widen the Swappable requirement to support proxy iterators. Here +is example code:

    -
    template<class Y> shared_ptr(shared_ptr<Y> const& r, T *p);
-
    +
    namespace Mine {
 
-
    
-reflects the intent of
-N2351
-to, well, allow the creation of an empty shared_ptr
-with a non-NULL stored pointer.
-
    
+template <class T>
+struct proxy {...};
 
-
    
-This is contradicted by the second sentence in the Returns clause of 20.8.10.2.5 [util.smartptr.shared.obs]:
-
    
+template <class T>
+struct proxied_iterator
+{
+   typedef T value_type;
+   typedef proxy<T> reference;
+   reference operator*() const;
+   ...
+};
 
-
    
-
    T* get() const;
-
    
-
    
-Returns: the stored pointer. Returns a null pointer if *this is empty.
-
    
-
    
+struct A
+{
+   // heavy type, has an optimized swap, maybe isn't even copyable or movable, just swappable
+   void swap(A&);
+   ...
+};
 
-
    [
-Bellevue:
-]
    
+void swap(A&, A&);
+void swap(proxy<A>, A&);
+void swap(A&, proxy<A>);
+void swap(proxy<A>, proxy<A>);
 
+}  // Mine
+
+...
+
+Mine::proxied_iterator<Mine::A> i(...)
+Mine::A a;
+swap(*i1, a);
+
    -
    -

    -Adopt option 1 and move to review, not ready. -

    -There was a lot of confusion about what an empty shared_ptr is (the term -isn't defined anywhere), and whether we have a good mental model for how -one behaves. We think it might be possible to deduce what the definition -should be, but the words just aren't there. We need to open an issue on -the use of this undefined term. (The resolution of that issue might -affect the resolution of issue 711.) +The key point to note in the above code is that in the call to swap, *i1 +and a are different types (currently types can only be Swappable with the +same type). A secondary point is that to support proxies, one must be able to pass rvalues +to swap. But note that I am not stating that the general purpose std::swap +should accept rvalues! Only that overloaded swaps, as in the example above, be allowed +to take rvalues.

    +

    -The LWG is getting more uncomfortable with the aliasing proposal (N2351) -now that we realize some of its implications, and we need to keep an eye -on it, but there isn't support for removing this feature at this time. +That is, no standard library code needs to change. We simply need to have a more flexible +definition of Swappable.

    -

    [ -Sophia Antipolis: +Bellevue: ]

    -We heard from Peter Dimov, who explained his reason for preferring solution 1. -

    -

    -Because it doesn't seem to add anything. It simply makes the behavior -for p = 0 undefined. For programmers who don't create empty pointers -with p = 0, there is no difference. Those who do insist on creating them -presumably have a good reason, and it costs nothing for us to define the -behavior in this case. -

    -

    -The aliasing constructor is sharp enough as it is, so "protecting" users -doesn't make much sense in this particular case. +While we believe Concepts work will define a swappable concept, we +should still resolve this issue if possible to give guidance to the +Concepts work.

    -> Do you have a use case for r being empty and r being non-null? +Would an ambiguous swap function in two namespaces found by ADL break +this wording? Suggest that the phrase "valid expression" means such a +pair of types would still not be swappable.

    -I have received a few requests for it from "performance-conscious" -people (you should be familiar with this mindset) who don't like the -overhead of allocating and maintaining a control block when a null -deleter is used to approximate a raw pointer. It is obviously an "at -your own risk", low-level feature; essentially a raw pointer behind a -shared_ptr facade. +Motivation is proxy-iterators, but facility is considerably more +general. Are we happy going so far?

    -We could not agree upon a resolution to the issue; some of us thought -that Peter's description above is supporting an undesirable behavior. +We think this wording is probably correct and probably an improvement on +what's there in the WP. On the other hand, what's already there in the +WP is awfully complicated. Why do we need the two bullet points? They're +too implementation-centric. They don't add anything to the semantics of +what swap() means, which is there in the post-condition. What's wrong +with saying that types are swappable if you can call swap() and it +satisfies the semantics of swapping?

    [ -2009-07 Frankfurt: +2009-07-28 Reopened by Alisdair. No longer solved by concepts. +]

    + + +

    [ +2009-10 Santa Cruz: ]

    -

    -We favor option 1, move to Ready. -

    +Leave as Open. Dave to provide wording. +
    +

    [ -Howard: Option 2 commented out for clarity, and can be brought back. +2009-11-08 Howard adds: ]

    + +
    +Updated wording to sync with +N3000. +Also this issue is very closely related to 594.

    Proposed resolution:

    -In keeping the N2351 spirit and obviously my preference, change 20.8.10.2.5 [util.smartptr.shared.obs]: +Change 20.2.1 [utility.arg.requirements]:

    -
    T* get() const;
-
    -

    -Returns: the stored pointer. Returns a null pointer if *this is empty. -

    + +

    +-1- The template definitions in the C++ Standard Library refer to various +named requirements whose details are set out in tables 31-38. In these +tables, T and V are is a types to be supplied by a C++ program +instantiating a template; a, b, and c are +values of type const T; s and t are modifiable +lvalues of type T; u is a value of type (possibly +const) T; and rv is a non-const +rvalue of type T; w is a value of type T; and v is a value of type V. +

    + + + + + + + +
    Table 37: Swappable requirements [swappable]
    expressionReturn typePost-condition
    swap(sw,tv)voidtw has the value originally +held by uv, and +uv has the value originally held +by tw
    +

    +The Swappable requirement is met by satisfying one or more of the following conditions: +

    +
      +
    • +T is Swappable if T and V are +the same type and T satisfies the +MoveConstructible requirements (Table +33) and the +MoveAssignable requirements (Table +35); +
      • +
    • +T is Swappable with V if a namespace scope function named +swap exists in the same namespace as the definition of +T or V, such that the expression +swap(sw,t v) is valid and has the +semantics described in this table. +
      • +
    • +T is Swappable if T is an array type whose +element type is Swappable. +
      • +
    +
    +

    Rationale:

    +

    [ +post San Francisco: +]

    + + +
    +Solved by +N2758. +
    +
    -

    716. Production in [re.grammar] not actually modified

    -

    Section: 28.13 [re.grammar] Status: Ready - Submitter: Stephan T. Lavavej Opened: 2007-08-31 Last modified: 2009-07-16

    -

    View all issues with Ready status.

    +

    774. Member swap undefined for most containers

    +

    Section: 23 [containers] Status: Open + Submitter: Alisdair Meredith Opened: 2008-01-14 Last modified: 2009-10-31

    +

    View other active issues in [containers].

    +

    View all other issues in [containers].

    +

    View all issues with Open status.

    Discussion:

    -TR1 7.13 [tr.re.grammar]/3 and C++0x WP 28.13 [re.grammar]/3 say: +It appears most containers declare but do not define a member-swap +function.

    -

    -The following productions within the ECMAScript grammar are modified as follows: +This is unfortunate, as all overload the swap algorithm to call the +member-swap function! +(required for swappable guarantees [Table 37] and Container Requirements +[Table 87])

    -
    CharacterClass ::
-[ [lookahead ∉ {^}] ClassRanges ]
-[ ^ ClassRanges ]
-
    - -
    -

    -This definition for CharacterClass appears to be exactly identical to that in ECMA-262. +Note in particular that Table 87 gives semantics of a.swap(b) as swap(a,b), +yet for all containers we define swap(a,b) to call a.swap(b) - a circular +definition.

    -Was an actual modification intended here and accidentally omitted, or was this production accidentally included? +A quick survey of clause 23 shows that the following containers provide a +definition for member-swap:

    -

    [ -Batavia (2009-05): -]

    +
    array
+queue
+stack
+vector
+
    -

    -We agree that what is specified is identical to what ECMA-262 specifies. -Pete would like to take a bit of time to assess whether we had intended, -but failed, to make a change. -It would also be useful to hear from John Maddock on the issue. +Whereas the following declare it, but do not define the semantics:

    + +
    deque
+list
+map
+multimap
+multiset
+priority_queue
+set
+unordered_map
+unordered_multi_map
+unordered_multi_set
+unordered_set
+
    +

    -Move to Open. +Suggested resolution:

    +
    +Provide a definition for each of the affected containers...

    [ -2009-07 Frankfurt: +Bellevue: ]

    -Move to Ready. +Move to Open and ask Alisdair to provide wording.
    +

    [ +2009-07 Frankfurt: +]

    -

    Proposed resolution:

    -

    -Remove this mention of the CharacterClass production. -

    - -
    CharacterClass ::
-[ [lookahead ∉ {^}] ClassRanges ]
-[ ^ ClassRanges ]
-
    - - - - +
    +Daniel to provide wording. +N2590 +is no longer applicable. +
    +

    [ +2009-07-28 Daniel provided wording. +]

    -
    -

    719. std::is_literal type traits should be provided

    -

    Section: 20.6 [meta] Status: Open - Submitter: Daniel Krügler Opened: 2007-08-25 Last modified: 2009-07-16

    -

    View other active issues in [meta].

    -

    View all other issues in [meta].

    -

    View all issues with Open status.

    -

    Duplicate of: 750

    -

    Discussion:

    -

    -Since the inclusion of constexpr in the standard draft N2369 we have -a new type category "literal", which is defined in 3.9 [basic.types]/p.11: -

    -

    --11- A type is a literal type if it is: -

    -
      -
    • a scalar type; or
      • -

    • a class type (clause 9) with

      -
        -
      • a trivial copy constructor,
        • -
      • a trivial destructor,
        • -
      • at least one constexpr constructor other than the copy constructor,
        • -
      • no virtual base classes, and
        • -
      • all non-static data members and base classes of literal types; or
        • -
      +
        +
      1. +It assumes that the proposed resolution for 883 is applied, +which breaks the circularity of definition between member +swap and free swap.
        2. -
      2. an array of literal type.
        3. -
    -
    -

    -I strongly suggest that the standard provides a type traits for -literal types in 20.6.4.3 [meta.unary.prop] for several reasons: -

    +
  • +It uses the notation of the pre-concept allocator trait +allocator_propagation_map, which might be renamed after the +next refactoring phase of generalized allocators. +
    • -
      -
    1. To keep the traits in sync with existing types.
      2. -
    2. I see many reasons for programmers to use this trait in template - code to provide optimized template definitions for these types, - see below.
      3. -
    3. A user-provided definition of this trait is practically impossible -to write portably.
      4. +
    4. +It requires that compare objects, key equal functions and +hash functions in containers are swapped via unqualified free +swap according to 594. +
    +
    + +

    [ +2009-09-30 Daniel adds: +]

    -

    -The special problem of reason (c) is that I don't see currently a -way to portably test the condition for literal class types: -

    -
      -
    • at least one constexpr constructor other than the copy constructor,
      • -
    +The outcome of this issue should be considered with the outcome of 1198 both in style and in content (e.g. bullet 9 suggests to +define the semantic of void +priority_queue::swap(priority_queue&) in terms of the member +swap of the container).
    - -

    [ -Alisdair is considering preparing a paper listing a number of missing -type traits, and feels that it might be useful to handle them all -together rather than piecemeal. This would affect issue 719 and 750. -These two issues should move to OPEN pending AM paper on type traits. +2009-10 Santa Cruz: ]

    +
    +Looked at, but took no action on as it overlaps too much with +N2982. +Waiting for a new draft WP. +
    +

    [ -2009-07 Frankfurt: +2009-10 Santa Cruz: ]

    -Beman, Daniel, and Alisdair will work on a paper proposing new type traits. +Leave as open. Pablo to provide wording.
    +

    [ +2009-10-26 Pablo updated wording. Here is the wording he replaced: +]

    -

    Proposed resolution:

    -

    -In 20.6.2 [meta.type.synop] in the group "type properties", -just below the line -

    - -
    template <class T> struct is_pod;
-
    +
    +
      +

    1. -add a new one: +Add a new Throws clause just after X [allocator.propagation.map]/5:

      -
      template <class T> struct is_literal;
-
      - +
      static void swap(Alloc& a, Alloc& b);
+
      +

      -In 20.6.4.3 [meta.unary.prop], table Type Property Predicates, just -below the line for the is_pod property add a new line: +Effects: [..]

      - - - - - - - - - -
      TemplateConditionPreconditions
      template <class T> struct is_literal;T is a literal type (3.9)T shall be a complete type, an -array of unknown bound, or -(possibly cv-qualified) void.
      - - - - - - -
      -

      723. basic_regex should be moveable

      -

      Section: 28.8 [re.regex] Status: Ready - Submitter: Daniel Krügler Opened: 2007-08-29 Last modified: 2009-07-16

      -

      View all other issues in [re.regex].

      -

      View all issues with Ready status.

      -

      Discussion:

      - -

      Addresses UK 316

      -

      -According to the current state of the standard draft, the class -template basic_regex, as described in 28.8 [re.regex]/3, is -neither MoveConstructible nor MoveAssignable. -IMO it should be, because typical regex state machines tend -to have a rather large data quantum and I have seen several -use cases, where a factory function returns regex values, -which would take advantage of moveabilities. +Throws: Nothing.

      - +
      +

      [ -Sophia Antipolis: +This exception requirement is added, such that it's combination with the +general container requirements of +N2723 +[container.requirements.general]/9 +make it unambiguously clear that the following descriptions of "swaps the +allocators" have the following meaning: (a) This swap is done by calling +allocator_propagation_map<allocator_type>::swap and (b) This allocator +swap does never propagate an exception ]

      +
      2. + +
    2. +

      +Change 23.2.4.1 [associative.reqmts.except]/3 as indicated: +

      -Needs wording for the semantics, the idea is agreed upon. +For associative containers, no swap function throws an exception unless that +exception is thrown by the copy constructor or copy assignment +operator +swap of the container's Pred objects (if any).
      +
      3. -

      [ -Post Summit Daniel updated wording to reflect new "swap rules". -]

      - +
    3. +

      +Change 23.2.5.1 [unord.req.except]/3 as indicated: +

      -

      [ -2009-07 Frankfurt: -]

      +
      +For unordered associative containers, no swap function throws an +exception unless +that exception is thrown by the copy constructor or copy +assignment operator +swap of the container's Hash or Pred objects, +respectively (if any). +
      +
      4. +
    4. +

      +Insert a new paragraph just after 23.3 [sequences]/1: +

      -Move to Ready. +In addition to being available via inclusion of the <algorithm> header, +the swap function templates in 25.3.3 [alg.swap] are also available when the +header <queue> is included.
      +

      [ +There is a new issue in process that will suggest a minimum header for swap +and move. If this one is provided, this text can be removed and the header +dependency should be added to <queue> +]

      -

      Proposed resolution:

      -

      -In the class definition of basic_regex, just below 28.8 [re.regex]/3, -perform the following changes: -

      +
      5. -

      1. -Just after basic_regex(const basic_regex&); insert: +Add one further clause at the end of 23.3.1.2 [array.special]:

        +

        [This part is added, because otherwise array::swap would otherwise +contradict the +general contract of 23.2.1 [container.requirements.general] p. 10 b. 5]

        -
        basic_regex(basic_regex&&);
-
        + +
        +Throws: Nothing, unless one of the element-wise swap calls throws +an exception. +
        2. +
      2. -

        -Just after basic_regex& operator=(const basic_regex&); insert: -

        -
        basic_regex& operator=(basic_regex&&);
-
        -
        3. +

        1. -Just after basic_regex& assign(const basic_regex& that); insert: +In 23.3.2 [deque], class template deque synopsis change as indicated:

          -
          basic_regex& assign(basic_regex&& that);
+
          void swap(deque<T,Alloc>&);
          2. +

        2. -In 28.8.2 [re.regex.construct], just after p.11 add the following -new member definition: +At the end of 23.3.2.3 [deque.modifiers] add as indicated:

          -
          basic_regex(basic_regex&& e);
+
+
          void swap(deque& x);
 
          
 
          
 
          
-Effects: Move-constructs a basic_regex instance from e.
-
          
-
          
-Postconditions: flags() and mark_count() return e.flags() and
-e.mark_count(), respectively,
-that e had before construction, leaving
-e in a valid state with an unspecified value.
+Effects: Exchanges the contents and swaps the allocators of *this
+with that of x.
 
          
 
          
-Throws: nothing.
+Complexity: Constant time.
          3. +
        + + +
      3. +

        1. -Also in 28.8.2 [re.regex.construct], just after p.18 add the -following new member definition: +In 23.3.3 [forwardlist], class template forward_list synposis change as indicated:

          -
          basic_regex& operator=(basic_regex&& e);
-
          -
          -Effects: Returns the result of assign(std::move(e)). -
          -
          +
          void swap(forward_list<T,Allocator>&);
+
          2. +

        2. -In 28.8.3 [re.regex.assign], just after p. 2 add the following new -member definition: +At the end of 23.3.3.4 [forwardlist.modifiers] add as indicated:

          -
          basic_regex& assign(basic_regex&& rhs);
+
+
          void swap(forward_list& x);
 
          
 
          
 
          
-Effects: Move-assigns a basic_regex instance from rhs and returns *this.
-
          
-
          
-Postconditions: flags() and mark_count() return rhs.flags()
-and rhs.mark_count(), respectively, that
-rhs had before assignment, leaving rhs
-in a valid state with an unspecified value.
+Effects: Exchanges the contents and swaps the allocators of *this
+with that of x.
 
          
 
          
-Throws: nothing.
+Complexity: Constant time.
        +
        4. +
      4. +
          +
        1. +

          +In 23.3.4 [list], class template list synopsis change as indicated: +

          +
          void swap(list<T,Allocator>&);
+
          +
          2. - - -
          -

          724. DefaultConstructible is not defined

          -

          Section: X [utility.arg.requirements] Status: Open - Submitter: Pablo Halpern Opened: 2007-09-12 Last modified: 2009-07-28

          -

          View other active issues in [utility.arg.requirements].

          -

          View all other issues in [utility.arg.requirements].

          -

          View all issues with Open status.

          -

          Discussion:

          +

        2. -The DefaultConstructible requirement is referenced in -several places in the August 2007 working draft -N2369, -but is not defined anywhere. +At the end of 23.3.4.3 [list.modifiers] add as indicated:

          -

          [ -Bellevue: -]

          - +
          void swap(list& x);
+

          -Walking into the default/value-initialization mess... -

          -

          -Why two lines? Because we need both expressions to be valid. -

          -

          -AJM not sure what the phrase "default constructed" means. This is -unfortunate, as the phrase is already used 24 times in the library! -

          -

          -Example: const int would not accept first line, but will accept the second. +Effects: Exchanges the contents and swaps the allocators of *this +with that of x.

          +

          -This is an issue that must be solved by concepts, but we might need to solve it independantly first. +Complexity: Constant time.

          +
          +
          +
          3. +
        +
        5. + +

      5. -It seems that the requirements are the syntax in the proposed first -column is valid, but not clear what semantics we need. +At the end of 23.3.5.2.2 [priqueue.members] add a new prototype description:

        + +
        void swap(priority_queue& q);
+
        +

        -A table where there is no post-condition seems odd, but appears to sum up our position best. +Requires: Compare shall satisfy the Swappable requirements +( [swappable]).

        + +

        [ +This requirement is added to ensure that even a user defined swap +which is found by +ADL for Compare satisfies the Swappable requirements +]

        + +

        -At a minimum an object is declared and is destuctible. +Effects: this->c.swap(q.c); swap(this->comp, q.comp);

        -Move to open, as no-one happy to produce wording on the fly. +Throws: What and if c.swap(q.c) and swap(comp, q.comp) throws.

        - +

        [ -2009-07-28 Reopened by Alisdair. No longer solved by concepts. +This part is added, because otherwise priority_queue::swap would otherwise +contradict the general contract of 23.2.1 [container.requirements.general] p. 10 b. 5 ]

        +
        6. +
      6. +
          +
        1. +

          +In 23.3.6 [vector], class template vector synopsis change as indicated: +

          +
          void swap(vector<T,Allocator>&);
+
          +
          2. -

          Proposed resolution:

          +

        2. -In section X [utility.arg.requirements], before table 33, add the -following table: +Change 23.3.6.2 [vector.capacity]/8 as indicated:

          -

          Table 33: DefaultConstructible requirements

          +
          void swap(vector<T,Allocator>& x);
+
          -
          +
          +Effects: Exchanges the contents and capacity() and swaps the +allocators +of *this with that of x. +
          +
          +
          3. +
        +
        7. - - - - - - - - - -
        -

        expression

        -         		-

        post-condition

        -
        -

        T - t;
        - T()

        -         		-

        T - is default constructed.

        -
        +
      7. +

        +Insert a new paragraph just before 23.4 [associative]/1: +

        - +
        +In addition to being available via inclusion of the <algorithm> header, +the swap function templates in 25.3.3 [alg.swap] are also available when any of the +headers <map> or <set> are included. +
        +
        8. +
      8. +
          +
        1. +

          +In 23.4.1 [map], class template map synopsis change as indicated: +

          +
          void swap(map<Key,T,Compare,Allocator>&);
+
          +
          2. + +
        2. +

          +At the end of 23.4.1.3 [map.modifiers] add as indicated: +

          + +
          void swap(map& x);
+
          + +
          +

          +Requires: Compare shall satisfy the Swappable requirements +( [swappable]). +

          -

          Rationale:

          [ -San Francisco: +This requirement is added to ensure that even a user defined swap +which is found by ADL for Compare satisfies the Swappable +requirements ]

          -
          -We believe concepts will solve this problem -(N2774). + +

          +Effects: Exchanges the contents and swaps the allocators of *this +with that of x, followed by an unqualified swap of the comparison objects +of *this and x. +

          + +

          +Complexity: Constant time +

          +
          +
          3. +
        +
        9. +
      9. +
          +
        1. +

          +In 23.4.2 [multimap], class template multimap synopsis change as indicated: +

          +
          void swap(multimap<Key,T,Compare,Allocator>&);
+
          +
          2. +
        2. +

          +At the end of 23.4.2.2 [multimap.modifiers] add as indicated: +

          +
          void swap(multimap& x);
+
          -
          -

          726. Missing regex_replace() overloads

          -

          Section: 28.11.4 [re.alg.replace] Status: Open - Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-07-25

          -

          View other active issues in [re.alg.replace].

          -

          View all other issues in [re.alg.replace].

          -

          View all issues with Open status.

          -

          Discussion:

          +

          -Two overloads of regex_replace() are currently provided: +Requires: Compare shall satisfy the Swappable requirements +( [swappable]). +

          +

          +Effects: Exchanges the contents and swaps the allocators of *this +with that of x, followed by an unqualified swap of the comparison objects +of *this and x. +

          +

          +Complexity: Constant time

          +
          +
          +
          3. +
        +
        10. -
        template <class OutputIterator, class BidirectionalIterator, 
-    class traits, class charT> 
-  OutputIterator 
-  regex_replace(OutputIterator out, 
-                BidirectionalIterator first, BidirectionalIterator last, 
-                const basic_regex<charT, traits>& e, 
-                const basic_string<charT>& fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
- 
-template <class traits, class charT> 
-  basic_string<charT> 
-  regex_replace(const basic_string<charT>& s, 
-                const basic_regex<charT, traits>& e, 
-                const basic_string<charT>& fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
+
      10. 
+
          
+
        1. 
+
          
+In 23.4.3 [set], class template set synopsis change as indicated:
+
          
+
+
          void swap(set<Key,Compare,Allocator>&);
 
          
+
          2. 
 
-
            
-
          1. Overloads taking const charT * are provided for regex_match() and
-regex_search(), but not regex_replace().  This is inconsistent.
            2. 
 
          2. 
-
            The absence of const charT * overloads prevents ordinary-looking code from compiling, such as:
            
+
            
+After section 23.4.3.1 [set.cons] add a new section set modifiers
+ [set.modifiers]
+and add the following paragraphs:
+
            
 
-
            const string s("kitten");
-const regex r("en");
-cout << regex_replace(s, r, "y") << endl;
-
            
+
            void swap(set& x);
+
            
 
+
            
 
            
-The compiler error message will be something like "could not deduce
-template argument for 'const std::basic_string<_Elem> &' from 'const
-char[1]'".
+Requires: Compare shall satisfy the Swappable requirements
+( [swappable]).
 
            
 
 
            
-Users expect that anything taking a basic_string<charT> can also take a
-const charT *.  In their own code, when they write a function taking
-std::string (or std::wstring), they can pass a const char * (or const
-wchar_t *), thanks to basic_string's implicit constructor.  Because the
-regex algorithms are templated on charT, they can't rely on
-basic_string's implicit constructor (as the compiler error message
-indicates, template argument deduction fails first).
+Effects: Exchanges the contents and swaps the allocators of *this
+with that of x, followed by an unqualified swap of the comparison objects
+of *this and x.
 
            
 
 
            
-If a user figures out what the compiler error message means, workarounds
-are available - but they are all verbose.  Explicit template arguments
-could be given to regex_replace(), allowing basic_string's implicit
-constructor to be invoked - but charT is the last template argument, not
-the first, so this would be extremely verbose.  Therefore, constructing
-a basic_string from each C string is the simplest workaround.
+Complexity: Constant time
 
            
+
            
+
            
+
            3. 
+
          
 
 
 
        2. 
-There is an efficiency consideration: constructing basic_strings can
-impose performance costs that could be avoided by a library
-implementation taking C strings and dealing with them directly. 
-(Currently, for replacement sources, C strings can be converted into
-iterator pairs at the cost of verbosity, but for format strings, there
-is no way to avoid constructing a basic_string.)
+
            
+
          1. 
+
            
+In 23.4.4 [multiset], class template multiset synosis, change as indicated:
+
            
+
+
            void swap(multiset<Key,Compare,Allocator>&);
+
            
 
            2. 
-
          
 
-
          [
-Sophia Antipolis:
-]
          
+
        3. 
+
          
+After section 23.4.4.1 [multiset.cons] add a new section multiset modifiers
+ [multiset.modifiers] and add the following paragraphs:
+
          
 
+
          void swap(multiset& x);
+
          
 
 
          
-We note that Boost already has these overloads. However, the proposed
-wording is provided only for 28.11.4 [re.alg.replace]; wording is needed for the synopsis
-as well. We also note that this has impact on match_results::format,
-which may require further overloads.
-
          
+
          
+Requires: Compare shall satisfy the Swappable requirements
+( [swappable]).
+
          
 
-
          [
-2009-07 Frankfurt:
-]
          
+
          
+Effects: Exchanges the contents and swaps the allocators of *this
+with that of x, followed by an unqualified swap of the comparison objects
+of *this and x.
+
          
+
+
          
+Complexity: Constant time
+
          
+
          
+
        11. + +
      + +
    5. +

      +Insert a new paragraph just before 23.5 [unord]/1: +

      -Daniel to tweak for us. +In addition to being available via inclusion of the <algorithm> header, +the swap function templates in 25.3.3 [alg.swap] are also available when any of the +headers <unordered_map> or <unordered_set> are included.
      -

      [ -2009-07-25 Daniel tweaks both this issue and 727. -]

      +
      6. + +
    6. +

      +After section 23.5.1.2 [unord.map.elem] add a new section unordered_map +modifiers [unord.map.modifiers] and add the following paragraphs: +

      +
      void swap(unordered_map& x);
+

      -This is solved by the proposed resolution of 727. +Requires: Hash and Pred shall satisfy the Swappable requirements +( [swappable]).

      -
      - +

      [ +This requirement is added to ensure that even a user defined swap +which is found by ADL for Hash and Pred satisfies the Swappable +requirements +]

      -

      Proposed resolution:

      -Provide additional overloads for regex_replace(): one additional -overload of the iterator-based form (taking const charT* fmt), and three -additional overloads of the convenience form (one taking const charT* -str, another taking const charT* fmt, and the third taking both const -charT* str and const charT* fmt). 28.11.4 [re.alg.replace]: +Effects: Exchanges the contents and hash policy and swaps the +allocators of *this +with that of x, followed by an unqualified swap of the Pred objects +and an unqualified swap of the Hash objects of *this and x.

      -
      -
      template <class OutputIterator, class BidirectionalIterator, 
-    class traits, class charT> 
-  OutputIterator 
-  regex_replace(OutputIterator out, 
-                BidirectionalIterator first, BidirectionalIterator last, 
-                const basic_regex<charT, traits>& e, 
-                const basic_string<charT>& fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
+
      
+Complexity: Constant time
+
      
+
      +
      +
      7. -template <class OutputIterator, class BidirectionalIterator, - class traits, class charT> - OutputIterator - regex_replace(OutputIterator out, - BidirectionalIterator first, BidirectionalIterator last, - const basic_regex<charT, traits>& e, - const charT* fmt, - regex_constants::match_flag_type flags = - regex_constants::match_default); - -

      ...

      -
      template <class traits, class charT> 
-  basic_string<charT> 
-  regex_replace(const basic_string<charT>& s, 
-                const basic_regex<charT, traits>& e, 
-                const basic_string<charT>& fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
+
    7. 
+
      
+After section 23.5.2.1 [unord.multimap.cnstr] add a new section
+unordered_multimap
+modifiers  [unord.multimap.modifiers] and add the following paragraphs:
+
      
 
-template <class traits, class charT> 
-  basic_string<charT> 
-  regex_replace(const basic_string<charT>& s, 
-                const basic_regex<charT, traits>& e, 
-                const charT* fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
+
      void swap(unordered_multimap& x);
+
      
 
-template <class traits, class charT> 
-  basic_string<charT> 
-  regex_replace(const charT* s, 
-                const basic_regex<charT, traits>& e, 
-                const basic_string<charT>& fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
+
      
+
      
+Requires: Hash and Pred shall satisfy the Swappable requirements
+( [swappable]).
+
      
 
-template <class traits, class charT> 
-  basic_string<charT> 
-  regex_replace(const charT* s, 
-                const basic_regex<charT, traits>& e, 
-                const charT* fmt, 
-                regex_constants::match_flag_type flags = 
-                  regex_constants::match_default);
-
      8. +

      +Effects: Exchanges the contents and hash policy and swaps the +allocators of *this +with that of x, followed by an unqualified swap of the Pred objects +and an unqualified swap of the Hash objects of *this and x +

      +

      +Complexity: Constant time +

    + + +
  • +

    +After section 23.5.3.1 [unord.set.cnstr] add a new section +unordered_set modifiers + [unord.set.modifiers] and add the following paragraphs: +

    +
    void swap(unordered_set& x);
+
    +
    +

    +Requires: Hash and Pred shall satisfy the Swappable requirements +( [swappable]). +

    +

    +Effects: Exchanges the contents and hash policy and swaps the +allocators of *this +with that of x, followed by an unqualified swap of the Pred objects +and an unqualified swap of the Hash objects of *this and x +

    - -
    -

    727. regex_replace() doesn't accept basic_strings with custom traits and allocators

    -

    Section: 28.11.4 [re.alg.replace] Status: Open - Submitter: Stephan T. Lavavej Opened: 2007-09-22 Last modified: 2009-07-31

    -

    View other active issues in [re.alg.replace].

    -

    View all other issues in [re.alg.replace].

    -

    View all issues with Open status.

    -

    Discussion:

    -regex_match() and regex_search() take const basic_string<charT, ST, -SA>&. regex_replace() takes const basic_string<charT>&. This prevents -regex_replace() from accepting basic_strings with custom traits and -allocators. +Complexity: Constant time

    +
    +
    +
    • +

  • -Overloads of regex_replace() taking basic_string should be additionally -templated on class ST, class SA and take const basic_string<charT, ST, -SA>&. Consistency with regex_match() and regex_search() would place -class ST, class SA as the first template arguments; compatibility with -existing code using TR1 and giving explicit template arguments to -regex_replace() would place class ST, class SA as the last template -arguments. +After section 23.5.4.1 [unord.multiset.cnstr] add a new section +unordered_multiset +modifiers [unord.multiset.modifiers] and add the following paragraphs:

    -

    [ -Batavia (2009-05): -]

    +
    void swap(unordered_multiset& x);
+

    -Bill comments, "We need to look at the depth of this change." +Requires: Hash and Pred shall satisfy the Swappable requirements +( [swappable]).

    +

    -Pete remarks that we are here dealing with a convenience function -that saves a user from calling the iterato-based overload. +Effects: Exchanges the contents and hash policy and swaps the +allocators of *this +with that of x, followed by an unqualified swap of the Pred objects +and an unqualified swap of the Hash objects of *this and x

    -Move to Open. +Complexity: Constant time

    +
    +
    • -

    [ -2009-07 Frankfurt: -]

    - + -
    -Howard to ask Stephan Lavavej to provide wording.

    [ -2009-07-17 Stephan provided wording. +2009-10-30 Pablo and Daniel updated wording. ]

    + + +

    Proposed resolution:

    +

    [ -2009-07-25 Daniel tweaks both this issue and 726. +This resolution is based on the September 2009 WP, +N2960, +except that it +assumes that +N2982 +and issues 883 and 1232 have already been applied. Note in +particular that Table 91 in +N2960 +is refered to as Table 90 because +N2982 +removed the old Table 90. This resolution also addresses issue 431. ]

    +

    +In 23.2.1 [container.requirements.general], replace the a.swap(b) row in table 90, +"container requirements" (was table 91 before the application of N2982 to the +WP): +

    +
    + + + + + + + + + + + + + + + +
    a.swap(b)void   swap(a,b)Exchange the contents of a and b.(Note A)
    swap(a,b)void   a.swap(b)(Note A)
    +
    +

    +Modify the notes immediately following Table 90 in +23.2.1 [container.requirements.general] as follows (The wording below is after the +application of N2982 to N2960. The editor might also want to combine Notes +A and B into one.): +

    +

    +Notes: the algorithms swap(), equal() and lexicographical_compare() +are defined in Clause 25. Those entries marked "(Note A)" or "(Note B)" +should have linear complexity for array and constant +complexity for all other standard containers. +

    +

    +In 23.2.1 [container.requirements.general], after paragraph 9, add: +

    +

    +The expression a.swap(b), for containers a +and b of a standard container type other than array, +exchanges the values of a and b without invoking any +move, copy, or swap operations on the individual container elements. +Any Compare, Pred, or Hash function +objects belonging to a and b shall satisfy +the Swappable requirements and are exchanged by unqualified calls +to non-member swap. If +allocator_traits<allocator_type>::propagate_on_container_swap::value +== true, then the allocators of a and b are +also exchanged using an unqualified call to non-member swap. +Otherwise, the behavior is undefined unless a.get_allocator() == +b.get_allocator(). Each iterator refering to an element in one +container before the swap shall refer to the same element in the other +container after the swap. It is unspecified whether an iterator with +value a.end() before the swap will have +value b.end() after the swap. In addition to being available via +inclusion of the <utility> header, the swap +function template in 25.3.3 [alg.swap] is also available within the definition of +every standard container's swap function. +

    +

    [ +Note to the editor: Paragraph 2 starts with a sentence fragment, +clearly from an editing or source-control error. +]

    +

    +Modify 23.2.4.1 [associative.reqmts.except] as follows: +

    -One relevant part of the proposed resolution below suggests -to add a new overload of the format member function in the -match_results class template that accepts two character pointers -defining the begin and end of a format range. A more general -approach could have proposed a pair of iterators instead, but -the used pair of char pointers reflects existing practice. If the -committee strongly favors an iterator-based signature, this -could be simply changed. I think that the minimum requirement -should be a BidirectionalIterator, but current implementations -take advantage (at least partially) of the RandomAccessIterator -sub interface of the char pointers. +23.2.4.1 Exception safety guarantees 23.2.4.1 [associative.reqmts.except] +

    +

    +For associative containers, no clear() function throws an +exception. erase(k) does not throw an exception unless that +exception is thrown by the +container's PredCompare object (if any).

    +

    +For associative containers, if an exception is thrown by any operation from +within an insert() function inserting a single element, +the insert() function has no effect. +

    +

    +For associative containers, no swap function throws an exception +unless that exception is thrown by the copy constructor +or copy assignment operatorswap of the +container's PredCompare object (if any). +

    +

    +Modify 23.2.5.1 [unord.req.except], paragraph 3 as follows: +

    +

    +For unordered associative containers, no swap function throws an +exception unless that exception is thrown by the copy constructor or copy +assignment operatorswap of the container's Hash +or Pred object (if any). +

    +

    +Modify section 23.3.1.2 [array.special]: +

    +
    +

    +array specialized algorithms 23.3.1.2 [array.special] +

    +

    +template <class T, size_t N> void swap(array<T,N>& x,array<T,N>& y); +

    +
    +

    +Effects: swap_ranges(x.begin(), x.end(), y.begin() );x.swap(y); +

    +
    +
    +

    +Add a new section after 23.3.1.5 [array.fill] (Note to the editor: array::fill make use +of a concept requirement that must be removed or changed to text.): +

    +
    +

    +array::swap [array.swap] +

    +

    +void swap(array& y); +

    +
    +

    +Effects: swap_ranges(this->begin(), this->end(), y.begin() ); +

    +

    +Throws: Nothing unless one of the element-wise swap calls throws an +exception. +

    +

    +[Note: Unlike other containers' swap functions, +array::swap takes linear, not constant, time, may exit via an +exception, and does not cause iterators to become associated with the other +container. — end note] +

    +
    +
    -

    Suggested Resolution:

    +

    +Insert a new paragraph just after 23.3.5 [container.adaptors]/1: +

    +

    +For container adaptors, no swap function throws an exception +unless that exception is thrown by the swap of the +adaptor's Container or Compare object (if any). +

    -

    [Moved into the proposed resloution]

    - -

    [ -2009-07-30 Stephan agrees with Daniel's wording. Howard places Daniel's wording -in the Proposed Resolution. -]

    -

    Proposed resolution:

    -
      -
    1. + + +
      +

      780. std::merge() specification incorrect/insufficient

      +

      Section: 25.4.4 [alg.merge] Status: Review + Submitter: Daniel Krügler Opened: 2008-01-25 Last modified: 2009-10-22

      +

      View all issues with Review status.

      +

      Discussion:

      -Change 28.4 [re.syn] as indicated: +Though issue 283 has fixed many open issues, it seems that some are still open:

      -
      // 28.11.4, function template regex_replace:
-template <class OutputIterator, class BidirectionalIterator,
-          class traits, class charT, class ST, class SA>
-  OutputIterator
-  regex_replace(OutputIterator out,
-                BidirectionalIterator first, BidirectionalIterator last,
-                const basic_regex<charT, traits>& e,
-                const basic_string<charT, ST, SA>& fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-template <class OutputIterator, class BidirectionalIterator,
-          class traits, class charT>
-  OutputIterator
-  regex_replace(OutputIterator out,
-                BidirectionalIterator first, BidirectionalIterator last,
-                const basic_regex<charT, traits>& e,
-                const charT* fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-template <class traits, class charT, class ST, class SA,
-          class FST, class FSA>
-  basic_string<charT, ST, SA>
-  regex_replace(const basic_string<charT, ST, SA>& s,
-                const basic_regex<charT, traits>& e,
-                const basic_string<charT, FST, FSA>& fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-template <class traits, class charT, class ST, class SA>
-  basic_string<charT, ST, SA>
-  regex_replace(const basic_string<charT, ST, SA>& s,
-                const basic_regex<charT, traits>& e,
-                const charT* fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-
-template <class traits, class charT, class ST, class SA>
-  basic_string<charT>
-  regex_replace(const charT* s,
-                const basic_regex<charT, traits>& e,
-                const basic_string<charT, ST, SA>& fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
+
      
+Both 25.3.4 [lib.alg.merge] in 14882:2003 and 25.4.4 [alg.merge] in N2461
+have no Requires element and the Effects element contains some requirements,
+which is probably editorial. Worse is that:
+
      
 
-
-template <class traits, class charT>
-  basic_string<charT>
-  regex_replace(const charT* s,
-                const basic_regex<charT, traits>& e,
-                const charT* fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
      +
        +
      • +no assignment requirements are specified (neither implicit nor explicit).
      • -

        -Change 28.10 [re.results]/3, class template match_results as -indicated: -

        +the effects clause just speaks of "merges", which is badly worded +near to a circular definition. +
        • -
        
-template <class OutputIter>
-  OutputIter
-  format(OutputIter out,
-         const char_type* fmt_first, const char_type* fmt_last,
-         regex_constants::match_flag_type flags =
-           regex_constants::format_default) const;
-
+
      • 
+p. 2 mentions a range [first, last), which is not defined by the
+function arguments or otherwise.
+
        • 
 
-template <class OutputIter, class ST, class SA>
-  OutputIter
-  format(OutputIter out,
-         const string_typebasic_string<char_type, ST, SA>& fmt,
-         regex_constants::match_flag_type flags =
-           regex_constants::format_default) const;
+
      • 
+p. 2 says "according to the ordering defined by comp" which is both
+incomplete (because
+this excludes the first variant with <) and redundant (because the
+following subordinate
+clause mentions comp again)
+
        • 
+
      -template <class ST, class SA> - string_typebasic_string<char_type, ST, SA> - format(const string_typebasic_string<char_type, ST, SA>& fmt, - regex_constants::match_flag_type flags = - regex_constants::format_default) const; +

      [ +Post Summit Alisdair adds: +]

      - -string_type -format(const char_type* fmt, - regex_constants::match_flag_type flags = - regex_constants::format_default) const; - - -
      2. -
    2. +

      -Insert at the very beginning of 28.10.4 [re.results.form] the following: +Suggest:

      - -
      
-template <class OutputIter>
-  OutputIter
-  format(OutputIter out,
-         const char_type* fmt_first, const char_type* fmt_last,
-         regex_constants::match_flag_type flags =
-           regex_constants::format_default) const;
-
-
      - -

      -1 Requires: The type OutputIter shall satisfy the requirements for an -Output Iterator (24.2.3 [output.iterators]). -

      - -

      -2 Effects: Copies the character sequence [fmt_first,fmt_last) to -OutputIter out. Replaces each -format specifier or escape sequence in the copied range with either -the character(s) it represents -or the sequence of characters within *this to which it refers. The -bitmasks specified in flags -determines what format specifiers and escape sequences are recognized. -

      - -

      -3 Returns: out. -

      -
      +(where last is equal to next(result, distance(first1, last1) + +distance(first2, last2)), such that resulting range will be sorted in +non-decreasing order; that is, for every iterator i in [result,last) other +than result, the condition *i < *prev(i) or, respectively, comp(*i, +*prev(i)) will be false.
      -
      3. -

    3. -Change 28.10.4 [re.results.form], before p. 1 until p. 3 (according to -previous numbering) -as indicated: +Note that this might still not be technically accurate in the case of +InputIterators, depending on other resolutions working their way through the +system (1011).

      + -
      template <class OutputIter, class ST, class SA>
-  OutputIter
-  format(OutputIter out,
-         const string_typebasic_string<char_type, ST, SA>& fmt,
-         regex_constants::match_flag_type flags =
-           regex_constants::format_default) const;
-
      +

      [ +Post Summit Daniel adds: +]

      + + +
      +If we want to use prev and next here (Note: merge +is sufficiently satisfied with InputIterator) we should instead *add* more to +25 [algorithms]/6, but I can currently not propose any good wording for this. +
      + +

      [ +Batavia (2009-05): +]

      -Requires: The type OutputIter shall satisfy the requirements for -an Output Iterator (24.2.3). +Pete points out the existing wording in [algorithms]/4 +that permits the use of + in algorithm specifications.

      -

      -Effects: Copies the character sequence [fmt.begin(),fmt.end()) to -OutputIter out. Replaces each -format specifier or escape sequence in fmt with either the -character(s) it represents or the sequence of -characters within *this to which it refers. The bitmasks specified in -flags determines what format -specifiers and escape sequences are recognized. +Alisdair points out that that wording may not apply to input iterators.

      -

      -Returns: outformat(out, fmt.data(), fmt.data() + -fmt.size(), flags). +Move to Review.

      + +

      [ +2009-07 Frankfurt: +]

      + + +
      +Move to Ready.
      -
      4. -
    4. -

      -Change 28.10.4 [re.results.form], before p. 4 until p. 4 (according to -previous numbering) as indicated: -

      +

      [ +2009-08-23 Daniel reopens: +]

      -
      template <class ST, class SA>
-  string_typebasic_string<char_type, ST, SA>
-  format(const string_typebasic_string<char_type, ST, SA>& fmt,
-         regex_constants::match_flag_type flags =
-           regex_constants::format_default) const;
-

      -Effects: Returns a copy of the string fmt. Replaces each format -specifier or escape sequence -in fmt with either the character(s) it represents or the sequence of -characters within *this to which -it refers. The bitmasks specified in flags determines what format -specifiers and escape sequences are -recognized. Constructs an empty string result of type -basic_string<char_type, ST, SA>, -and calls format(back_inserter(result), fmt, flags). +The proposed wording must be rephrased, because the part

      +
      +for every iterator i in [result,last) other than result, the condition +*i < *(i - 1) or, respectively, comp(*i, *(i - 1)) will be false" +
      +

      -Returns: result +isn't meaningful, because the range [result,last) is that of a pure +OutputIterator, which is not readable in general.

      + +

      [Howard: Proposed wording updated by Daniel, status moved from Ready to Review.]

      +
      -
      -
      5. -
    5. +

      [ +2009-10 Santa Cruz: +]

      + + +

      -At the end of 28.10.4 [re.results.form] insert as indicated: +Matt has some different words to propose. Those words have been moved into +the proposed wording section, and the original proposed wording now appears +here: +

      +
      +

      +In 25.4.4 [alg.merge] replace p.1+ 2:

      - -
      
-string_type
-  format(const char_type* fmt,
-         regex_constants::match_flag_type flags =
-           regex_constants::format_default) const;
-

      -Effects: Constructs an empty string result of type string_type, and calls -format(back_inserter(result), fmt, fmt + -char_traits<char_type>::length(fmt), flags). +Effects: MergesCopies all the elements of the +two sorted ranges +[first1,last1) and [first2,last2) into the range [result,result + +(last1 - first1) + (last2 - first2)) +, such that resulting range will be sorted in non-decreasing +order; that is for every +pair of iterators i and j of either input ranges, where *i was copied +to the output range +before *j was copied to the output range, the condition *j < *i or, +respectively, comp(*j, *i) +will be false.

      +

      -Returns: result +Requires:The resulting range shall not overlap with either +of the original ranges. +The list will be sorted in non-decreasing order according to the +ordering defined by +comp; that is, for every iterator i in [first,last) other than first, +the condition *i < *(i - 1) or +comp(*i, *(i - 1)) will be false.

      +
      -
      6. -
    6. -

      -Change 28.11.4 [re.alg.replace] before p. 1 as indicated: -

      - -
      template <class OutputIterator, class BidirectionalIterator,
-          class traits, class charT, class ST, class SA>
-  OutputIterator
-  regex_replace(OutputIterator out,
-                BidirectionalIterator first, BidirectionalIterator last,
-                const basic_regex<charT, traits>& e,
-                const basic_string<charT, ST, SA>& fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-template <class OutputIterator, class BidirectionalIterator,
-          class traits, class charT>
-  OutputIterator
-  regex_replace(OutputIterator out,
-                BidirectionalIterator first, BidirectionalIterator last,
-                const basic_regex<charT, traits>& e,
-                const charT* fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
      - -
      -Effects: [..]. If any matches are found then, for each such match, if !(flags & - regex_constants::format_no_copy) calls std::copy(m.prefix().first, -m.prefix().second, - out), and then calls m.format(out, fmt, flags) for the first -form of the function - and m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags) -for the second - form. [..]. -
      -
      -
      7. - -
    7. -

      -Change 28.11.4 [re.alg.replace] before p. 3 as indicated: -

      - -
      template <class traits, class charT, class ST, class SA,
-          class FST, class FSA>
-  basic_string<charT, ST, SA>
-  regex_replace(const basic_string<charT, ST, SA>& s,
-                const basic_regex<charT, traits>& e,
-                const basic_string<charT, FST, FSA>& fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-template <class traits, class charT, class ST, class SA>
-  basic_string<charT, ST, SA>
-  regex_replace(const basic_string<charT, ST, SA>& s,
-                const basic_regex<charT, traits>& e,
-                const charT* fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
      -
      -Effects: Constructs an empty string result of type basic_string<charT, -ST, SA>, calls regex_replace(back_inserter(result), s.begin(), s.end(), -e, fmt, flags), and then returns result. -
      -
      -
      8. +

      Proposed resolution:

      +

      +Effects: Merges two sorted ranges [first1,last1) and +[first2,last2) into the range [result, result + (last1 - +first1) + (last2 - first2)). +

      +

      +Effects: Copies all the elements of the two sorted ranges +[first1,last1) and [first2,last2) into the range +[result, result_last), where result_last is result ++ (last1 - first1) + (last2 - first2), such that the resulting +range satisfies is_sorted(result, result_last) or +is_sorted(result, result_last, comp), respectively. +

      -

    8. -At the end of 28.11.4 [re.alg.replace] add the following new prototype description: +Requires: The resulting range shall not overlap with +either of the original ranges. The list will be sorted in +non-decreasing order according to the ordering defined by comp; +that is, for every iterator i in [first,last) other +than first, the condition *i < *(i - 1) or +comp(*i, *(i - 1)) will be false.

      -
      
-template <class traits, class charT, class ST, class SA>
-  basic_string<charT>
-  regex_replace(const charT* s,
-                const basic_regex<charT, traits>& e,
-                const basic_string<charT, ST, SA>& fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
-
-
-template <class traits, class charT>
-  basic_string<charT>
-  regex_replace(const charT* s,
-                const basic_regex<charT, traits>& e,
-                const charT* fmt,
-                regex_constants::match_flag_type flags =
-                  regex_constants::match_default);
-
      - -
      - -Effects: Constructs an empty string result of type basic_string<charT>, -calls regex_replace(back_inserter(result), s, s + -char_traits<charT>::length(s), -e, fmt, flags), and then returns result. - -
      -
      -
      9. - -
    - -
    -

    742. Enabling swap for proxy iterators

    -

    Section: X [utility.arg.requirements] Status: Open - Submitter: Howard Hinnant Opened: 2007-10-10 Last modified: 2009-07-28

    -

    View other active issues in [utility.arg.requirements].

    -

    View all other issues in [utility.arg.requirements].

    +

    801. tuple and pair trivial members

    +

    Section: 20.5 [tuple] Status: Open + Submitter: Lawrence Crowl Opened: 2008-02-18 Last modified: 2009-10-23

    +

    View all other issues in [tuple].

    View all issues with Open status.

    Discussion:

    -This issue was split from 672. 672 now just -deals with changing the requirements of T in the Swappable -requirement from CopyConstructible and CopyAssignable to -MoveConstructible and MoveAssignable. +Classes with trivial special member functions are inherently more +efficient than classes without such functions. This efficiency is +particularly pronounced on modern ABIs that can pass small classes +in registers. Examples include value classes such as complex numbers +and floating-point intervals. Perhaps more important, though, are +classes that are simple collections, like pair and tuple. When the +parameter types of these classes are trivial, the pairs and tuples +themselves can be trivial, leading to substantial performance wins.

    -

    -This issue seeks to widen the Swappable requirement to support proxy iterators. Here -is example code: +The current working draft make specification of trivial functions +(where possible) much easer through defaulted and deleted functions. +As long as the semantics of defaulted and deleted functions match +the intended semantics, specification of defaulted and deleted +functions will yield more efficient programs. +

    +

    +There are at least two cases where specification of an explicitly +defaulted function may be desirable. +

    +

    +First, the std::pair template has a non-trivial default constructor, +which prevents static initialization of the pair even when the +types are statically initializable. Changing the definition to

    -
    namespace Mine {
-
-template <class T>
-struct proxy {...};
-
-template <class T>
-struct proxied_iterator
-{
-   typedef T value_type;
-   typedef proxy<T> reference;
-   reference operator*() const;
-   ...
-};
-
-struct A
-{
-   // heavy type, has an optimized swap, maybe isn't even copyable or movable, just swappable
-   void swap(A&);
-   ...
-};
-
-void swap(A&, A&);
-void swap(proxy<A>, A&);
-void swap(A&, proxy<A>);
-void swap(proxy<A>, proxy<A>);
+
    pair() = default;
+
    
 
-}  // Mine
+
    
+would enable such initialization.  Unfortunately, the change is
+not semantically neutral in that the current definition effectively
+forces value initialization whereas the change would not value
+initialize in some contexts.
+
    
 
-...
+
    
+** Does the committee confirm that forced value initialization
+was the intent?  If not, does the committee wish to change the
+behavior of std::pair in C++0x?
+
    
+
    
+Second, the same default constructor issue applies to std::tuple.
+Furthermore, the tuple copy constructor is current non-trivial,
+which effectively prevents passing it in registers.  To enable
+passing tuples in registers, the copy constructor should be
+make explicitly defaulted.  The new declarations are:
+
    
 
-Mine::proxied_iterator<Mine::A> i(...)
-Mine::A a;
-swap(*i1, a);
+
    tuple() = default;
+tuple(const tuple&) = default;
 
    
 
 
    
-The key point to note in the above code is that in the call to swap, *i1
-and a are different types (currently types can only be Swappable with the
-same type).  A secondary point is that to support proxies, one must be able to pass rvalues
-to swap.  But note that I am not stating that the general purpose std::swap
-should accept rvalues!  Only that overloaded swaps, as in the example above, be allowed
-to take rvalues.
+This changes is not implementation neutral.  In particular, it
+prevents implementations based on pointers to the parameter
+types.  It does however, permit implementations using the
+parameter types as bases.
 
    
-
 
    
-That is, no standard library code needs to change.  We simply need to have a more flexible
-definition of Swappable.
+** How does the committee wish to trade implementation
+efficiency versus implementation flexibility?
 
    
 
 
    [
@@ -8453,1468 +6945,1128 @@ Bellevue:
 
 
    
 
    
-While we believe Concepts work will define a swappable concept, we
-should still resolve this issue if possible to give guidance to the
-Concepts work.
+General agreement; the first half of the issue is NAD.
 
    
 
    
-Would an ambiguous swap function in two namespaces found by ADL break
-this wording? Suggest that the phrase "valid expression" means such a
-pair of types would still not be swappable.
+Before voting on the second half, it was agreed that a "Strongly Favor"
+vote meant support for trivial tuples (assuming usual requirements met),
+even at the expense of other desired qualities. A "Weakly Favor" vote
+meant support only if not at the expense of other desired qualities.
 
    
 
    
-Motivation is proxy-iterators, but facility is considerably more
-general. Are we happy going so far?
+Concensus: Go forward, but not at expense of other desired qualities.
 
    
 
    
-We think this wording is probably correct and probably an improvement on
-what's there in the WP. On the other hand, what's already there in the
-WP is awfully complicated. Why do we need the two bullet points? They're
-too implementation-centric. They don't add anything to the semantics of
-what swap() means, which is there in the post-condition. What's wrong
-with saying that types are swappable if you can call swap() and it
-satisfies the semantics of swapping?
+It was agreed to Alisdair should fold this work in with his other
+pair/tuple action items, above, and that issue 801 should be "open", but
+tabled until Alisdair's proposals are disposed of.
 
    
 
    
 
 
    [
-2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+2009-05-27 Daniel adds:
 ]
    
 
 
+
    
+This is partly solved by 1117.
+
    
 
+
    [
+2009-07 Frankfurt:
+]
    
 
-
    Proposed resolution:
    
-
    
-Change X [utility.arg.requirements]:
-
    
 
 
    
+Wait for dust to settle from fixing exception safety problem
+with rvalue refs.
+
    
+
+
    [
+2009-07-20 Alisdair adds:
+]
    
+
 
+
    
 
    
--1- The template definitions in the C++ Standard Library refer to various
-named requirements whose details are set out in tables 31-38. In these
-tables, T and V are is a types to be supplied by a C++ program
-instantiating a template; a, b, and c are
-values of type const T; s and t are modifiable
-lvalues of type T; u is a value of type (possibly
-const) T; and rv is a non-const
-rvalue of type T; w is a value of type T; and v is a value of type V.
+Basically, this issue is what should we do with the default constructor
+for pairs and tuples of trivial types.  The motivation of the issue was
+to force static initialization rather than dynamic initialization, and
+was rejected in the case of pair as it would change the meaning of
+existing programs.  The advice was "do the best we can" for tuple
+without changing existing meaning.
 
    
 
-
-
-
-
-
-
-
    Table 37: Swappable requirements [swappable]
    expressionreturn typepost-condition
    swap(sw,tv)voidtw has the value originally
-held by uv, and
-uv has the value originally held
-by tw
    
 
    
-The Swappable requirement is met by satisfying one or more of the following conditions:
+Frankfurt seems to simply wait and see the resolution on no-throw move
+constructors, which (I believe) is only tangentially related to this
+issue, but as good as any to defer until Santa Cruz.
 
    
-
      
-
    • 
-T is Swappable if T and V are
-the same type and  T satisfies the
-CopyConstructible
-MoveConstructible requirements (Table 34
-33) and the CopyAssignable
-MoveAssignable requirements (Table 36
-35);
-
      • 
-
    • 
-T is Swappable with V if a namespace scope function named
-swap exists in the same namespace as the definition of
-T or V, such that the expression
-swap(tw,u v) is valid and has the
-semantics described in this table.
-
      • 
-
    
-
    
-
    
-
 
+
    
+Looking again now, I think constant (static) initialization for pair can
+be salvaged by making the default construct constexpr.  I have a
+clarification from Core that this is intended to work, even if the
+constructor is not trivial/constexpr, so long as no temporaries are
+implied in the process (even if elided).
+
    
+
    -

    Rationale:

    [ -post San Francisco: +2009-10 Santa Cruz: ]

    -Solved by -N2758. +Leave as open. Alisdair to provide wording.
    +

    Proposed resolution:

    +

    +

    + +
    -

    774. Member swap undefined for most containers

    -

    Section: 23 [containers] Status: Open - Submitter: Alisdair Meredith Opened: 2008-01-14 Last modified: 2009-07-30

    -

    View other active issues in [containers].

    -

    View all other issues in [containers].

    +

    811. pair of pointers no longer works with literal 0

    +

    Section: 20.3.4 [pairs] Status: Open + Submitter: Doug Gregor Opened: 2008-03-14 Last modified: 2009-10-23

    +

    View other active issues in [pairs].

    +

    View all other issues in [pairs].

    View all issues with Open status.

    Discussion:

    -

    -It appears most containers declare but do not define a member-swap -function. -

    - -

    -This is unfortunate, as all overload the swap algorithm to call the -member-swap function! -(required for swappable guarantees [Table 37] and Container Requirements -[Table 87]) -

    +
    #include <utility>
 
-
    
-Note in particular that Table 87 gives semantics of a.swap(b) as swap(a,b),
-yet for all containers we define swap(a,b) to call a.swap(b) - a circular
-definition.
-
    
+int main()
+{
+   std::pair<char *, char *> p (0,0);
+}
+

    -A quick survey of clause 23 shows that the following containers provide a -definition for member-swap: +I just got a bug report about that, because it's valid C++03, but not +C++0x. The important realization, for me, is that the emplace +proposal---which made push_back variadic, causing the push_back(0) +issue---didn't cause this break in backward compatibility. The break +actually happened when we added this pair constructor as part of adding +rvalue references into the language, long before variadic templates or +emplace came along:

    -
    array
-queue
-stack
-vector
+
    template<class U, class V> pair(U&& x, V&& y);
 
    
 
 
    
-Whereas the following declare it, but do not define the semantics:
+Now, concepts will address this issue by constraining that pair
+constructor to only U's and V's that can properly construct "first" and
+"second", e.g. (from
+N2322):
 
    
 
-
    deque
-list
-map
-multimap
-multiset
-priority_queue
-set
-unordered_map
-unordered_multi_map
-unordered_multi_set
-unordered_set
+
    template<class U , class V >
+requires Constructible<T1, U&&> && Constructible<T2, V&&>
+pair(U&& x , V&& y );
 
    
 
-
    
-Suggested resolution:
-
    
-
    
-Provide a definition for each of the affected containers...
-
    
-
 
    [
-Bellevue:
+San Francisco:
 ]
    
 
 
 
    
-Move to Open and ask Alisdair to provide wording.
+
    
+Suggested to resolve using pass-by-value for that case.
+
    
+
    
+Side question: Should pair interoperate with tuples? Can construct a
+tuple of a pair, but not a pair from a two-element tuple.
+
    
+
    
+Related to 885.
+
    
 
    
 
 
    [
-2009-07 Frankfurt:
+2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
 ]
    
 
 
-
    
-Daniel to provide wording.
-N2590
-is no longer applicable.
-
    
-
 
    [
-2009-07-28 Daniel provided wording.
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-
      
-
    1. 
-It assumes that the proposed resolution for 883 is applied,
-which breaks the circularity of definition between member
-swap and free swap.
-
      2. 
-
-
    2. 
-It uses the notation of the pre-concept allocator trait
-allocator_propagation_map, which might be renamed after the
-next refactoring phase of generalized allocators.
-
      3. 
-
-
    3. 
-It requires that compare objects, key equal functions and
-hash functions in containers are swapped via unqualified free
-swap according to 594.
-
      4. 
-
    
+Leave as open. Howard to provide wording.
 
    
 
 
+
 
    Proposed resolution:
    
-
      
-
    1. 
 
      
-Add a new Throws clause just after X [allocator.propagation.map]/5:
 
      
 
-
      static void swap(Alloc& a, Alloc& b);
-
      
-
      
-
      
-Effects: [..]
-
      
 
-
      
-Throws: Nothing.
-
      
-
      
-
      
+
      Rationale:
      
 
      [
-This exception requirement is added, such that it's combination with the
-general container requirements of
-N2723
-[container.requirements.general]/9
-make it unambiguously clear that the following descriptions of "swaps the
-allocators" have the following meaning: (a) This swap is done by calling
-allocator_propagation_map<allocator_type>::swap and (b) This allocator
-swap does never propagate an exception
+San Francisco:
 ]
      
 
-
      2. 
-
-
    2. 
-
      
-Change 23.2.4.1 [associative.reqmts.except]/3 as indicated:
-
      
 
 
      
-For associative containers, no swap function throws an exception unless that
-exception is thrown by the copy constructor or copy assignment
-operator
-swap of the container's Pred objects (if any).
+Solved by
+N2770.
 
      
-
      3. 
 
-
    3. 
-
      
-Change 23.2.5.1 [unord.req.except]/3 as indicated:
-
      
 
-
      
-For unordered associative containers, no swap function throws an
-exception unless
-that exception is thrown by the copy constructor or copy
-assignment operator
-swap of the container's Hash or Pred objects,
-respectively (if any).
-
      
-
      4. 
 
-
    4. 
+
+
+
+
+
      
+
      815. std::function and reference_closure do not use perfect forwarding
      
+
      Section: 20.7.15.2.4 [func.wrap.func.inv] Status: Open
+ Submitter: Alisdair Meredith Opened: 2008-03-16  Last modified: 2009-10-23
      
+
      View all issues with Open status.
      
+
      Discussion:
      
 
      
-Insert a new paragraph just after 23.3 [sequences]/1:
+std::function and reference_closure should use "perfect forwarding" as
+described in the rvalue core proposal.
 
      
 
+
      [
+Sophia Antipolis:
+]
      
+
+
 
      
-In addition to being available via inclusion of the <algorithm> header,
-the swap function templates in 25.4.3 [alg.swap] are also available when the
-header <queue> is included.
+According to Doug Gregor, as far as std::function is concerned, perfect
+forwarding can not be obtained because of type erasure. Not everyone
+agreed with this diagnosis of forwarding.
 
      
 
 
      [
-There is a new issue in process that will suggest a minimum header for swap
-and move. If this one is provided, this text can be removed and the header
-dependency should be added to <queue>
+2009-05-01 Howard adds:
 ]
      
 
 
-
      5. 
-
-
    5. 
+
      
 
      
-Add one further clause at the end of 23.3.1.2 [array.special]:
+Sebastian Gesemann brought to my attention that the CopyConstructible
+requirement on function's ArgTypes... is an unnecessary
+restriction.
 
      
-
      [This part is added, because otherwise array::swap would otherwise
-contradict the
-general contract of 23.2.1 [container.requirements.general] p. 10 b. 5]
      
 
+
      template<Returnable R, CopyConstructible... ArgTypes>
+class function<R(ArgTypes...)>
+...
+
      
 
-
      
-Throws: Nothing, unless one of the element-wise swap calls throws
-an exception.
-
      
-
      6. 
-
-
    6. 
-
        
-
      1. 
 
        
-In 23.3.2 [deque], class template deque synopsis change as indicated:
+On further investigation, this complaint seemed to be the same
+issue as this one.  I believe the reason CopyConstructible was put
+on ArgTypes in the first place was because of the nature of the
+invoke member:
 
        
-
        void swap(deque<T,Alloc>&);
-
        
-
        2. 
 
-
      2. 
-
        
-At the end of 23.3.2.3 [deque.modifiers] add as indicated:
-
        
+
        template<class R, class ...ArgTypes>
+R
+function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
+{
+    if (f_ == 0)
+        throw bad_function_call();
+    return (*f_)(arg...);
+}
+
        
 
-
        void swap(deque& x);
-
        
-
        
-
        
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x.
-
        
 
        
-Complexity: Constant time.
+However now with rvalue-refs, "by value" no longer implies CopyConstructible
+(as Sebastian correctly points out).  If rvalue arguments are supplied, MoveConstructible
+is sufficient.  Furthermore, the constraint need not be applied in function
+if I understand correctly.  Rather the client must apply the proper constraints
+at the call site.  Therefore, at the very least, I recommend that CopyConstructible
+be removed from the template class function.
 
        
-
        
-
        
-
        3. 
-
      
-
      7. 
 
-
    7. 
-
        
-
      1. 
 
        
-In 23.3.3 [forwardlist], class template forward_list synposis change as indicated:
+Furthermore we need to mandate that the invoker is coded as:
 
        
 
-
        void swap(forward_list<T,Allocator>&);
+
        template<class R, class ...ArgTypes>
+R
+function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
+{
+    if (f_ == 0)
+        throw bad_function_call();
+    return (*f_)(std::forward<ArgTypes>(arg)...);
+}
 
        
-
        2. 
 
-
      2. 
 
        
-At the end of 23.3.3.4 [forwardlist.modifiers] add as indicated:
+Note that ArgTypes&& (the "perfect forwarding signature") is not 
+appropriate here as this is not a deduced context for ArgTypes.  Instead
+the client's arguments must implicitly convert to the non-deduced ArgType
+type.  Catching these arguments by value makes sense to enable decay.
 
        
 
-
        void swap(forward_list& x);
-
        
-
        
-
        
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x.
-
        
 
        
-Complexity: Constant time.
+Next forward is used to move the ArgTypes as efficiently as
+possible, and also with minimum requirements (not CopyConstructible)
+to the type-erased functor.  For object types, this will be a move.  For
+reference type ArgTypes, this will be a copy.  The end result must be
+that the following is a valid program:
 
        
-
        
-
        
-
        3. 
-
      
-
      8. 
 
-
    8. 
-
        
-
      1. 
-
        
-In 23.3.4 [list], class template list synopsis change as indicated:
-
        
+
        #include <functional>
+#include <memory>
+#include <cassert>
 
-
        void swap(list<T,Allocator>&);
+std::unique_ptr<int>
+f(std::unique_ptr<int> p, int& i)
+{
+    ++i;
+    return std::move(p);
+}
+
+int main()
+{
+    int i = 2;
+    std::function<std::unique_ptr<int>(std::unique_ptr<int>,
+                                       int&> g(f);
+    std::unique_ptr<int> p = g(std::unique_ptr<int>(new int(1)), i);
+    assert(*p == 1);
+    assert(i == 3);
+}
 
        
-
        2. 
 
-
      2. 
-
        
-At the end of 23.3.4.3 [list.modifiers] add as indicated:
-
        
+
        [
+Tested in pre-concepts rvalue-ref-enabled compiler.
+]
        
 
-
        void swap(list& x);
-
        
 
-
        
 
        
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x.
+In the example above, the first ArgType is unique_ptr<int>
+and the second ArgType is int&.  Both must work!
 
        
 
-
        
-Complexity: Constant time.
-
        
 
        
-
        
-
        3. 
-
      
-
      9. 
-
-
    9. 
-
      
-At the end of 23.3.5.2.2 [priqueue.members] add a new prototype description:
-
      
-
-
      void swap(priority_queue& q);
-
      
-
      
-
      
-Requires: Compare shall satisfy the Swappable requirements
-( [swappable]).
-
      
 
 
      [
-This requirement is added to ensure that even a user defined swap
-which is found by
-ADL for Compare satisfies the Swappable requirements
+2009-05-27 Daniel adds:
 ]
      
 
 
+
      
 
      
-Effects: this->c.swap(q.c); swap(this->comp, q.comp);
-
      
-
      
-Throws: What and if c.swap(q.c) and swap(comp, q.comp) throws.
+in the 2009-05-01 comment of above mentioned issue Howard
 
      
-
      
-
      
-
      [
-This part is added, because otherwise priority_queue::swap would otherwise
-contradict the general contract of 23.2.1 [container.requirements.general] p. 10 b. 5
-]
      
-
-
      10. 
 
-
    10. 
 
        
 
      1. 
+Recommends to replace the CopyConstructible requirement by a
+MoveConstructible requirement
+
        2. 
+
      2. 
+Says: "Furthermore, the constraint need not be applied in function if I
+understand correctly. Rather the client must apply the proper constraints
+at the call site"
+
        3. 
+
      
 
      
-In 23.3.6 [vector], class template vector synopsis change as indicated:
+I'm fine with (a), but I think comment (b) is incorrect, at least in the
+sense I read these sentences. Let's look at Howard's example code:
 
      
 
-
      void swap(vector<T,Allocator>&);
+
      function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
+{
+   if (f_ == 0)
+       throw bad_function_call();
+   return (*f_)(std::forward<ArgTypes>(arg)...);
+}
 
      
-
      11. 
 
-
    11. 
 
      
-Change 23.3.6.2 [vector.capacity]/8 as indicated:
+In the constrained scope of this operator() overload the expression
+"(*f_)(std::forward<ArgTypes>(arg)...)" must be valid. How can it
+do so, if ArgTypes aren't at least MoveConstructible?
 
      
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
 
-
    void swap(vector<T,Allocator>& x);
-
    
 
 
    
-Effects: Exchanges the contents and capacity() and swaps the
-allocators
-of *this with that of x.
-
    
+Leave this open and wait until concepts are removed from the Working
+Draft so that we know how to write the proposed resolution in terms of
+diffs to otherwise stable text.
 
    
-
-
-
 
-
  • 
-
    
-Insert a new paragraph just before 23.4 [associative]/1:
-
    
+
    [
+2009-10 Santa Cruz:
+]
    
+
 
 
    
-In addition to being available via inclusion of the <algorithm> header,
-the swap function templates in 25.4.3 [alg.swap] are also available when any of the
-headers <map> or <set> are included.
+Leave as open. Howard to provide wording. Howard welcomes any help.
 
    
-
    • 
 
-
  • 
-
      
-
    1. 
-
      
-In 23.4.1 [map], class template map synopsis change as indicated:
-
      
 
-
      void swap(map<Key,T,Compare,Allocator>&);
-
      
-
      2. 
 
-
    2. 
+
      Proposed resolution:
      
 
      
-At the end of 23.4.1.3 [map.modifiers] add as indicated:
 
      
 
-
      void swap(map& x);
-
      
 
-
      
-
      
-Requires: Compare shall satisfy the Swappable requirements
-( [swappable]).
-
      
 
-
      [
-This requirement is added to ensure that even a user defined swap
-which is found by ADL for Compare satisfies the Swappable
-requirements
-]
      
 
 
+
      
+
      816. Should bind()'s returned functor have a nofail copy ctor when bind() is nofail?
      
+
      Section: 20.7.11.1.3 [func.bind.bind] Status: Ready
+ Submitter: Stephan T. Lavavej Opened: 2008-02-08  Last modified: 2009-11-07
      
+
      View other active issues in [func.bind.bind].
      
+
      View all other issues in [func.bind.bind].
      
+
      View all issues with Ready status.
      
+
      Discussion:
      
 
      
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x, followed by an unqualified swap of the comparison objects
-of *this and x.
+Library Issue 527 notes that bind(f, t1, ..., tN)
+should be nofail when f, t1, ..., tN have nofail copy ctors.
 
      
-
 
      
-Complexity: Constant time
+However, no guarantees are provided for the copy ctor of the functor
+returned by bind().  (It's guaranteed to have a copy ctor, which can
+throw implementation-defined exceptions: bind() returns a forwarding
+call wrapper, TR1 3.6.3/2.  A forwarding call wrapper is a call wrapper,
+TR1 3.3/4.  Every call wrapper shall be CopyConstructible, TR1 3.3/4.
+Everything without an exception-specification may throw
+implementation-defined exceptions unless otherwise specified, C++03
+17.4.4.8/3.)
+
      
+
      
+Should the nofail guarantee requested by Library Issue 527 be extended
+to cover both calling bind() and copying the returned functor?
 
      
+
+
      [
+Howard adds:
+]
      
+
+
+
      
+tuple construction should probably have a similar guarantee.
 
      
+
+
      [
+San Francisco:
+]
      
+
+
+
      
+Howard to provide wording.
 
      
-
      3. 
-
    
-
    • 
 
-
  • 
-
      
-
    1. 
-
      
-In 23.4.2 [multimap], class template multimap synopsis change as indicated:
-
      
+
      [
+Post Summit, Anthony provided wording.
+]
      
 
-
      void swap(multimap<Key,T,Compare,Allocator>&);
-
      
-
      2. 
 
-
    2. 
-
      
-At the end of 23.4.2.2 [multimap.modifiers] add as indicated:
-
      
+
      [
+Batavia (2009-05):
+]
      
+
+
      
+Part of all of this issue appears to be rendered moot
+by the proposed resolution to issue 817 (q.v.).
+We recommend the issues be considered simultaneously
+(or possibly even merged)
+to ensure there is no overlap.
+Move to Open, and likewise for issue 817.
+
      
+
+
      [
+2009-07 Frankfurt:
+]
      
+
+
+
      
+Related to 817 (see below). Leave Open.
+
      
+
+
      [
+2009-10 Santa Cruz:
+]
      
 
-
      void swap(multimap& x);
-
      
 
 
      
+Move to Ready. Decoupling from issue 817.
+
      
+
+
+
+
      Proposed resolution:
      
 
      
-Requires: Compare shall satisfy the Swappable requirements
-( [swappable]).
+Add a new sentence to the end of paragraphs 2 and 4 of 20.7.11.1.3 [func.bind.bind]:
 
      
+
+
      
 
      
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x, followed by an unqualified swap of the comparison objects
-of *this and x.
+-2- Returns: A forwarding call wrapper g with a weak result type (20.6.2). The effect of g(u1, u2,
+..., uM) shall be INVOKE(f, v1, v2, ..., vN, Callable<F cv,V1, V2, ..., VN>::result_type), where cv
+represents the cv-qualifiers of g and the values and types of the bound arguments
+v1, v2, ..., vN are determined as specified below.
+The copy constructor and move constructor of the forwarding call wrapper shall throw an
+exception if and only if the corresponding constructor of F or any of the types
+in BoundArgs... throw an exception.
 
      
+
      ...
      
 
      
-Complexity: Constant time
+-5- Returns: A forwarding call wrapper g with a nested type result_type defined as a synonym
+for R. The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, R), where the
+values and types of the bound arguments v1, v2, ..., vN are determined as specified below.
+The copy constructor and move constructor of the forwarding call wrapper shall throw an
+exception if and only if the corresponding constructor of F or any of the types
+in BoundArgs... throw an exception.
 
      
+
 
      
-
      
-
      3. 
-
    
-
    • 
 
-
  • 
-
      
-
    1. 
-
      
-In 23.4.3 [set], class template set synopsis change as indicated:
-
      
 
-
      void swap(set<Key,Compare,Allocator>&);
-
      
-
      2. 
 
-
    2. 
-
      
-After section 23.4.3.1 [set.cons] add a new section set modifiers
- [set.modifiers]
-and add the following paragraphs:
-
      
 
-
      void swap(set& x);
-
      
 
-
      
+
      
+
      817. bind needs to be moved
      
+
      Section: 20.7.11.1.3 [func.bind.bind] Status: Open
+ Submitter: Howard Hinnant Opened: 2008-03-17  Last modified: 2009-11-08
      
+
      View other active issues in [func.bind.bind].
      
+
      View all other issues in [func.bind.bind].
      
+
      View all issues with Open status.
      
+
      Discussion:
      
+
      Addresses US 72, JP 38 and DE 21
      
+
 
      
-Requires: Compare shall satisfy the Swappable requirements
-( [swappable]).
+The functor returned by bind() should have a move constructor that
+requires only move construction of its contained functor and bound arguments.
+That way move-only functors can be passed to objects such as thread.
 
      
-
 
      
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x, followed by an unqualified swap of the comparison objects
-of *this and x.
+This issue is related to issue 816.
 
      
 
 
      
-Complexity: Constant time
+US 72:
 
      
+
+
      
+bind should support move-only functors and bound arguments.
 
      
-
      
-
      3. 
-
    
-
    • 
 
-
  • 
-
      
-
    1. 
 
      
-In 23.4.4 [multiset], class template multiset synosis, change as indicated:
+JP 38:
 
      
 
-
      void swap(multiset<Key,Compare,Allocator>&);
-
      
-
      2. 
-
-
    2. 
+
      
 
      
-After section 23.4.4.1 [multiset.cons] add a new section multiset modifiers
- [multiset.modifiers] and add the following paragraphs:
+add the move requirement for bind's return type.
+
      
+
      
+For example, assume following th1 and th2,
 
      
 
-
      void swap(multiset& x);
-
      
+
      void f(vector<int> v) { }
+
+vector<int> v{ ... };
+thread th1([v]{ f(v); });
+thread th2(bind(f, v));
+
      
 
-
      
 
      
-Requires: Compare shall satisfy the Swappable requirements
-( [swappable]).
+When function object are set to thread, v is moved to th1's lambda
+expression in a Move Constructor of lambda expression because th1's lambda
+expression has a Move Constructor. But bind of th2's
+return type doesn't have the requirement of Move, so it may not
+moved but copied.
 
      
-
 
      
-Effects: Exchanges the contents and swaps the allocators of *this
-with that of x, followed by an unqualified swap of the comparison objects
-of *this and x.
+Add the requirement of move to get rid of this useless copy.
 
      
-
 
      
-Complexity: Constant time
+And also, add the MoveConstructible as well as CopyConstructible.
 
      
 
      
-
      
-
      3. 
-
    
-
    • 
 
-
  • 
 
    
-Insert a new paragraph just before 23.5 [unord]/1:
+DE 21
 
    
 
 
    
-In addition to being available via inclusion of the <algorithm> header,
-the swap function templates in 25.4.3 [alg.swap] are also available when any of the
-headers <unordered_map> or <unordered_set> are included.
+The specification for bind claims twice that "the values and types for
+the bound arguments v1, v2, ..., vN are determined as specified below".
+No such specification appears to exist.
 
    
 
-
    • 
-
-
  • 
-
    
-After section 23.5.1.2 [unord.map.elem] add a new section unordered_map
-modifiers  [unord.map.modifiers] and add the following paragraphs:
-
    
+
    [
+San Francisco:
+]
    
 
-
    void swap(unordered_map& x);
-
    
 
 
    
-
    
-Requires: Hash and Pred shall satisfy the Swappable requirements
-( [swappable]).
-
    
+Howard to provide wording.
+
    
 
 
    [
-This requirement is added to ensure that even a user defined swap
-which is found by ADL for Hash and Pred satisfies the Swappable
-requirements
+Post Summit Alisdair and Howard provided wording.
 ]
    
 
 
+
    
 
    
-Effects: Exchanges the contents and hash policy and swaps the
-allocators of *this
-with that of x, followed by an unqualified swap of the Pred objects
-and an unqualified swap of the Hash objects of *this and x.
+Several issues are being combined in this resolution.  They are all touching the
+same words so this is an attempt to keep one issue from stepping on another, and
+a place to see the complete solution in one place.
 
    
 
-
    
-Complexity: Constant time
-
    
-
    
-
    
+
      
+
    1. 
+bind needs to be "moved".
 
      2. 
-
 
    2. 
-
      
-After section 23.5.2.1 [unord.multimap.cnstr] add a new section
-unordered_multimap
-modifiers  [unord.multimap.modifiers] and add the following paragraphs:
-
      
+20.7.11.1.3 [func.bind.bind]/p3, p6 and p7 were accidently removed from N2798.
+
      3. 
+
    3. 
+Issue 929 argues for a way to pass by && for
+efficiency but retain the decaying behavior of pass by value for the
+thread constructor.  That same solution is applicable here.
+
      4. 
+
    
+
    • -
    void swap(unordered_multimap& x);
-
    +

    [ +Batavia (2009-05): +]

    -Requires: Hash and Pred shall satisfy the Swappable requirements -( [swappable]). -

    - -

    -Effects: Exchanges the contents and hash policy and swaps the -allocators of *this -with that of x, followed by an unqualified swap of the Pred objects -and an unqualified swap of the Hash objects of *this and x +We were going to recommend moving this issue to Tentatively Ready +until we noticed potential overlap with issue 816 (q.v.).

    -Complexity: Constant time +Move to Open, +and recommend both issues be considered together +(and possibly merged).

    -
    - -
  • -

    -After section 23.5.3.1 [unord.set.cnstr] add a new section -unordered_set modifiers - [unord.set.modifiers] and add the following paragraphs: -

    +

    [ +2009-07 Frankfurt: +]

    -
    void swap(unordered_set& x);
-
    -

    -Requires: Hash and Pred shall satisfy the Swappable requirements -( [swappable]). -

    - -

    -Effects: Exchanges the contents and hash policy and swaps the -allocators of *this -with that of x, followed by an unqualified swap of the Pred objects -and an unqualified swap of the Hash objects of *this and x -

    - -

    -Complexity: Constant time -

    -
    +The proposed resolution uses concepts. Leave Open.
    -
    • -
  • -

    -After section 23.5.4.1 [unord.multiset.cnstr] add a new section -unordered_multiset -modifiers [unord.multiset.modifiers] and add the following paragraphs: -

    +

    [ +2009-10 Santa Cruz: +]

    -
    void swap(unordered_multiset& x);
-
    -

    -Requires: Hash and Pred shall satisfy the Swappable requirements -( [swappable]). -

    - -

    -Effects: Exchanges the contents and hash policy and swaps the -allocators of *this -with that of x, followed by an unqualified swap of the Pred objects -and an unqualified swap of the Hash objects of *this and x -

    -

    -Complexity: Constant time -

    +Leave as Open. Howard to provide deconceptified wording.
    -
    -
    • - - - +

    [ +2009-11-07 Howard updates wording. +]

    -
    -

    780. std::merge() specification incorrect/insufficient

    -

    Section: 25.5.4 [alg.merge] Status: Ready - Submitter: Daniel Krügler Opened: 2008-01-25 Last modified: 2009-07-16

    -

    View all issues with Ready status.

    -

    Discussion:

    +

    Proposed resolution:

    -Though issue 283 has fixed many open issues, it seems that some are still open: +Change 20.7 [function.objects] p2:

    +
    template<class Fn, class... Types BoundArgs>
+  unspecified bind(Fn&&, Types BoundArgs&&...);
+template<class R, class Fn, class... Types BoundArgs>
+  unspecified bind(Fn&&, Types BoundArgs&&...);
+
    +

    -Both 25.3.4 [lib.alg.merge] in 14882:2003 and 25.5.4 [alg.merge] in N2461 -have no Requires element and the Effects element contains some requirements, -which is probably editorial. Worse is that: +Change 20.7.11.1.3 [func.bind.bind]:

    -
      -
    • -no assignment requirements are specified (neither implicit nor explicit). -
      • - -
    • -the effects clause just speaks of "merges", which is badly worded -near to a circular definition. -
      • - -
    • -p. 2 mentions a range [first, last), which is not defined by the -function arguments or otherwise. -
      • +
      +

      +Within this clause: +

      -
    • -p. 2 says "according to the ordering defined by comp" which is both -incomplete (because -this excludes the first variant with <) and redundant (because the -following subordinate -clause mentions comp again) -
      • +
        +
      • +Let FD be a synonym for the type decay<F>::type. +
        • +
      • +Let fd be an lvalue of type FD constructed from +std::forward<F>(f). +
        • +
      • +Let Ti be a synonym for the ith type in the +parameter pack BoundArgs. +
        • +
      • +Let TiD be a synonym for the type decay<Ti>::type. +
        • +
      • +Let ti be the ith argument in bound_args. +
        • +
      • +Let tid be an lvalue of type TiD constructed from +std::forward<Ti>(ti). +
      -

      [ -Post Summit Alisdair adds: -]

      - +
      template<class F, class... BoundArgs>
+  unspecified bind(F&& f, BoundArgs&&... bound_args);
+

      -Suggest: -

      -
      -(where last is equal to next(result, distance(first1, last1) + -distance(first2, last2)), such that resulting range will be sorted in -non-decreasing order; that is, for every iterator i in [result,last) other -than result, the condition *i < *prev(i) or, respectively, comp(*i, -*prev(i)) will be false. -
      - -

      -Note that this might still not be technically accurate in the case of -InputIterators, depending on other resolutions working their way through the -system (1011). +-1- Requires: +is_constructible<FD, F>::value +shall be true. +is_constructible<TiD, Ti>::value +shall be true. +F and each Ti in +BoundArgs shall be CopyConstructible. +INVOKE(fd, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for some values +w1, w2, ..., wN, where N == sizeof...(bound_args).

      -
      - -

      [ -Post Summit Daniel adds: -]

      - - -
      -If we want to use prev and next here (Note: merge -is sufficiently satisfied with InputIterator) we should instead *add* more to -25 [algorithms]/6, but I can currently not propose any good wording for this. -
      - -

      [ -Batavia (2009-05): -]

      - -

      -Pete points out the existing wording in [algorithms]/4 -that permits the use of + in algorithm specifications. +-2- Returns: A forwarding call wrapper g with a weak +result type (20.7.2 [func.require]). The effect of g(u1, u2, +..., uM) shall be INVOKE(fd, v1, v2, ..., vN, +result_of<FD cv (V1, V2, ..., VN)>::type), where +cv represents the cv-qualifiers of g and the +values and types of the bound arguments v1, v2, ..., vN are +determined as specified below. +The copy constructor and move constructor of the forwarding call wrapper shall throw an +exception if and only if the corresponding constructor of FD or any of the types +TiD throw an exception.

      -Alisdair points out that that wording may not apply to input iterators. +-3- Throws: Nothing unless the copy +constructionor of +Ffd or of one of the values +tid types in the BoundArgs... pack +expansion throws an exception.

      -Move to Review. + +Remarks: The unspecified return type shall be +MoveConstructible. If all of FD and TiD are +CopyConstructible then the unspecified return type shall +be CopyConstructible. [Note: This implies that all of +FD and TiD shall be MoveConstructible — +end note] +

      -

      [ -2009-07 Frankfurt: -]

      - +
      template<class R, class F, class... BoundArgs>
+  unspecified bind(F&& f, BoundArgs&&... bound_args);
+
      -Move to Ready. -
      - - - -

      Proposed resolution:

      -In 25.5.4 [alg.merge] replace p.1+ 2: +-4- Requires: +is_constructible<FD, F>::value +shall be true. +is_constructible<TiD, Ti>::value +shall be true. +F and each Ti in +BoundArgs shall be CopyConstructible. +INVOKE(fd, w1, +w2, ..., wN) shall be a valid expression for some values w1, w2, +..., wN, where N == sizeof...(bound_args). +

      +

      +-5- Returns: A forwarding call wrapper g with a nested +type result_type defined as a synonym for R. The +effect of g(u1, u2, ..., uM) shall be INVOKE(fd, v1, +v2, ..., vN, R), where the values and types of the bound arguments +v1, v2, ..., vN are determined as specified below. +The copy constructor and move constructor of the forwarding call wrapper shall throw an +exception if and only if the corresponding constructor of FD or any of the types +TiD throw an exception.

      - -

      -Effects: Merges Copies all the elements of the two sorted ranges [first1,last1) and -[first2,last2) into the range -[result,result + (last1 - first1) + (last2 - first2)) -[result, last) (where last is equal to result + (last1 -- first1) + (last2 - first2)), such that resulting range will be -sorted in non-decreasing order; that is, for every iterator i in -[result,last) other than result, the condition *i < *(i - 1) or, -respectively, comp(*i, *(i - 1)) will be false. +-6- Throws: Nothing unless the copy +constructionor of +Ffd or of one of the values +tid types in the BoundArgs... pack +expansion throws an exception.

      -

      -Requires: The resulting range shall not overlap with either of the original ranges. The list will be sorted in non-decreasing -order according to the ordering defined by comp; that is, for every iterator i in -[first,last) other than first, the condition *i < *(i - 1) or -comp(*i, *(i - 1)) will be false. + +Remarks: The unspecified return type shall be +MoveConstructible. If all of FD and TiD are +CopyConstructible then the unspecified return type shall +be CopyConstructible. [Note: This implies that all of +FD and TiD shall be MoveConstructible — +end note] +

      -[N.B.: I attempted to reuse the wording style of inplace_merge, -therefore proposing to -insert ", respectively," between both predicate tests. This is no -strictly necessary as -other parts of <algorithm> show, just a matter of consistency] +-7- The values of the bound arguments v1, v2, ..., vN and +their corresponding types V1, V2, ..., VN depend on the types +TiD derived from +of the corresponding argument ti in bound_args of type +Ti in BoundArgs in +the call to bind and the +cv-qualifiers cv of the call wrapper g as +follows:

      +
        +
      • +if ti TiD is of has +type reference_wrapper<T> the argument is +tid.get() and its type Vi is +T&; +
        • +
      • +if the value of +std::is_bind_expression<TiD>::value is +true the argument is tid(u1, u2, ..., uM) +and its type Vi is result_of<TiD cv +(U1&, U2&, ..., UM&)>::type; +
        • +
      • +if the value j of +std::is_placeholder<TiD>::value is not zero +the argument is std::forward<Uj>(uj) and its type +Vi is Uj&&; +
        • +
      • +otherwise the value is tid and its type Vi +is TiD cv &. +
        • +
      +
      -
      -

      788. ambiguity in [istream.iterator]

      -

      Section: 24.6.1 [istream.iterator] Status: Ready - Submitter: Martin Sebor Opened: 2008-02-06 Last modified: 2009-07-16

      -

      View other active issues in [istream.iterator].

      -

      View all other issues in [istream.iterator].

      -

      View all issues with Ready status.

      -

      Discussion:

      - -

      Addresses UK 287

      -
      -

      -It is not clear what the initial state of an istream_iterator should be. Is -_value_ initialized by reading the stream, or default/value initialized? If -it is initialized by reading the stream, what happens if the initialization -is deferred until first dereference, when ideally the iterator value should -have been that of an end-of-stream iterator which is not safely -dereferencable? -

      +
      +

      819. rethrow_if_nested

      +

      Section: 18.8.6 [except.nested] Status: Open + Submitter: Alisdair Meredith Opened: 2008-03-25 Last modified: 2009-10-23

      +

      View other active issues in [except.nested].

      +

      View all other issues in [except.nested].

      +

      View all issues with Open status.

      +

      Discussion:

      -Recommendation: Specify _value_ is initialized by reading the stream, or -the iterator takes on the end-of-stream value if the stream is empty. +Looking at the wording I submitted for rethrow_if_nested, I don't think I +got it quite right.

      -

      -The description of how an istream_iterator object becomes an -end-of-stream iterator is a) ambiguous and b) out of date WRT -issue 468: +The current wording says:

      -istream_iterator reads (using operator>>) successive elements from the -input stream for which it was constructed. After it is constructed, and -every time ++ is used, the iterator reads and stores a value of T. If -the end of stream is reached (operator void*() on the stream returns -false), the iterator becomes equal to the end-of-stream iterator value. -The constructor with no arguments istream_iterator() always constructs -an end of stream input iterator object, which is the only legitimate -iterator to be used for the end condition. The result of operator* on an -end of stream is not defined. For any other iterator value a const T& is -returned. The result of operator-> on an end of stream is not defined. -For any other iterator value a const T* is returned. It is impossible to -store things into istream iterators. The main peculiarity of the istream -iterators is the fact that ++ operators are not equality preserving, -that is, i == j does not guarantee at all that ++i == ++j. Every time ++ -is used a new value is read. -
      - +
      template <class E> void rethrow_if_nested(const E& e);
+
      +

      -istream::operator void*() returns null if istream::fail() is true, -otherwise non-null. istream::fail() returns true if failbit or -badbit is set in rdstate(). Reaching the end of stream doesn't -necessarily imply that failbit or badbit is set (e.g., after -extracting an int from stringstream("123") the stream object will -have reached the end of stream but fail() is false and operator -void*() will return a non-null value). +Effects: Calls e.rethrow_nested() only if e +is publicly derived from nested_exception.

      +
      +

      -Also I would prefer to be explicit about calling fail() here -(there is no operator void*() anymore.) +This is trying to be a bit subtle, by requiring e (not E) to be publicly +derived from nested_exception the idea is that a dynamic_cast would be +required to be sure. Unfortunately, if e is dynamically but not statically +derived from nested_exception, e.rethrow_nested() is ill-formed.

      [ -Summit: +San Francisco: ]

      -Moved from Ready to Open for the purposes of using this issue to address NB UK 287. -Martin to handle. +Alisdair was volunteered to provide wording.

      [ -2009-07 Frankfurt: +2009-10 Santa Cruz: ]

      -

      -This improves the wording. -

      -

      -Move to Ready. -

      +Leave as Open. Alisdair to provide wording.

      Proposed resolution:

      -

      -Change 24.6.1 [istream.iterator]/1: -

      - -
      -istream_iterator reads (using operator>>) successive elements from the -input stream for which it was constructed. After it is constructed, and -every time ++ is used, the iterator reads and stores a value of T. If -the end of stream is reached the iterator fails to read and store a value of T -(operator void*() fail() on the stream returns -false true), the iterator becomes equal to the end-of-stream iterator value. -The constructor with no arguments istream_iterator() always constructs -an end of stream input iterator object, which is the only legitimate -iterator to be used for the end condition. The result of operator* on an -end of stream is not defined. For any other iterator value a const T& is -returned. The result of operator-> on an end of stream is not defined. -For any other iterator value a const T* is returned. It is impossible to -store things into istream iterators. The main peculiarity of the istream -iterators is the fact that ++ operators are not equality preserving, -that is, i == j does not guarantee at all that ++i == ++j. Every time ++ -is used a new value is read. -
      -

      801. tuple and pair trivial members

      -

      Section: 20.5 [tuple] Status: Open - Submitter: Lawrence Crowl Opened: 2008-02-18 Last modified: 2009-07-20

      -

      View all other issues in [tuple].

      +

      834. Unique_ptr::pointer requirements underspecified

      +

      Section: 20.8.14.2 [unique.ptr.single] Status: Open + Submitter: Daniel Krügler Opened: 2008-05-14 Last modified: 2009-10-26

      +

      View other active issues in [unique.ptr.single].

      +

      View all other issues in [unique.ptr.single].

      View all issues with Open status.

      Discussion:

      -Classes with trivial special member functions are inherently more -efficient than classes without such functions. This efficiency is -particularly pronounced on modern ABIs that can pass small classes -in registers. Examples include value classes such as complex numbers -and floating-point intervals. Perhaps more important, though, are -classes that are simple collections, like pair and tuple. When the -parameter types of these classes are trivial, the pairs and tuples -themselves can be trivial, leading to substantial performance wins. -

      -

      -The current working draft make specification of trivial functions -(where possible) much easer through defaulted and deleted functions. -As long as the semantics of defaulted and deleted functions match -the intended semantics, specification of defaulted and deleted -functions will yield more efficient programs. -

      -

      -There are at least two cases where specification of an explicitly -defaulted function may be desirable. -

      -

      -First, the std::pair template has a non-trivial default constructor, -which prevents static initialization of the pair even when the -types are statically initializable. Changing the definition to -

      - -
      pair() = default;
-
      - -

      -would enable such initialization. Unfortunately, the change is -not semantically neutral in that the current definition effectively -forces value initialization whereas the change would not value -initialize in some contexts. -

      - -

      -** Does the committee confirm that forced value initialization -was the intent? If not, does the committee wish to change the -behavior of std::pair in C++0x? +Issue 673 (including recent updates by 821) proposes a useful +extension point for unique_ptr by granting support for an optional +deleter_type::pointer to act as pointer-like replacement for element_type* +(In the following: pointer).

      -Second, the same default constructor issue applies to std::tuple. -Furthermore, the tuple copy constructor is current non-trivial, -which effectively prevents passing it in registers. To enable -passing tuples in registers, the copy constructor should be -make explicitly defaulted. The new declarations are: +Unfortunately no requirements are specified for the type pointer which has +impact on at least two key features of unique_ptr:

      -
      tuple() = default;
-tuple(const tuple&) = default;
-
      +
        +
      1. Operational fail-safety.
        2. +
      2. (Well-)Definedness of expressions.
        3. +

      -This changes is not implementation neutral. In particular, it -prevents implementations based on pointers to the parameter -types. It does however, permit implementations using the -parameter types as bases. -

      -

      -** How does the committee wish to trade implementation -efficiency versus implementation flexibility? +Unique_ptr specification makes great efforts to require that essentially *all* +operations cannot throw and therefore adds proper wording to the affected +operations of the deleter as well. If user-provided pointer-emulating types +("smart pointers") will be allowed, either *all* throw-nothing clauses have to +be replaced by weaker "An exception is thrown only if pointer's {op} throws +an exception"-clauses or it has to be said explicitly that all used +operations of +pointer are required *not* to throw. I understand the main focus of unique_ptr +to be as near as possible to the advantages of native pointers which cannot +fail and thus strongly favor the second choice. Also, the alternative position +would make it much harder to write safe and simple template code for +unique_ptr. Additionally, I assume that a general statement need to be given +that all of the expressions of pointer used to define semantics are required to +be well-formed and well-defined (also as back-end for 762).

      [ -Bellevue: +Sophia Antipolis: ]

      -General agreement; the first half of the issue is NAD. -

      -

      -Before voting on the second half, it was agreed that a "Strongly Favor" -vote meant support for trivial tuples (assuming usual requirements met), -even at the expense of other desired qualities. A "Weakly Favor" vote -meant support only if not at the expense of other desired qualities. -

      -

      -Concensus: Go forward, but not at expense of other desired qualities. +Howard: We maybe need a core concept PointerLike, but we don't need the +arithmetic (see shared_ptr vs. vector<T>::iterator.

      -It was agreed to Alisdair should fold this work in with his other -pair/tuple action items, above, and that issue 801 should be "open", but -tabled until Alisdair's proposals are disposed of. +Howard will go through and enumerate the individual requirements wrt. pointer for each member function.

      -

      [ -2009-05-27 Daniel adds: -]

      - - -
      -This is partly solved by 1117. -
      -

      [ 2009-07 Frankfurt: ]

      -Wait for dust to settle from fixing exception safety problem -with rvalue refs. +Move to Ready.

      [ -2009-07-20 Alisdair adds: +2009-10-15 Alisdair pulls from Ready: ]

      -Basically, this issue is what should we do with the default constructor -for pairs and tuples of trivial types. The motivation of the issue was -to force static initialization rather than dynamic initialization, and -was rejected in the case of pair as it would change the meaning of -existing programs. The advice was "do the best we can" for tuple -without changing existing meaning. +I hate to pull an issue out of Ready status, but I don't think 834 is +fully baked yet.

      -Frankfurt seems to simply wait and see the resolution on no-throw move -constructors, which (I believe) is only tangentially related to this -issue, but as good as any to defer until Santa Cruz. +For reference the proposed resolution is to add the following words:

      -

      -Looking again now, I think constant (static) initialization for pair can -be salvaged by making the default construct constexpr. I have a -clarification from Core that this is intended to work, even if the -constructor is not trivial/constexpr, so long as no temporaries are -implied in the process (even if elided). -

      +
      +unique_ptr<T, D>::pointer's operations shall be +well-formed, shall have well defined behavior, and shall not throw +exceptions.
      - - -

      Proposed resolution:

      -

      -

      - - - - - -
      -

      811. pair of pointers no longer works with literal 0

      -

      Section: 20.3.3 [pairs] Status: Open - Submitter: Doug Gregor Opened: 2008-03-14 Last modified: 2009-07-28

      -

      View other active issues in [pairs].

      -

      View all other issues in [pairs].

      -

      View all issues with Open status.

      -

      Discussion:

      -
      #include <utility>
-
-int main()
-{
-   std::pair<char *, char *> p (0,0);
-}
-
      -

      -I just got a bug report about that, because it's valid C++03, but not -C++0x. The important realization, for me, is that the emplace -proposal---which made push_back variadic, causing the push_back(0) -issue---didn't cause this break in backward compatibility. The break -actually happened when we added this pair constructor as part of adding -rvalue references into the language, long before variadic templates or -emplace came along: +This leaves me with a big question : which operations?

      -
      template<class U, class V> pair(U&& x, V&& y);
-
      -

      -Now, concepts will address this issue by constraining that pair -constructor to only U's and V's that can properly construct "first" and -"second", e.g. (from -N2322): +Are all pointer operations required to be nothrow, including operations +that have nothing to do with interactions with unique_ptr? This was +much simpler with concepts where we could point to operations within a +certain concept, and so nail down the interactions.

      - -
      template<class U , class V >
-requires Constructible<T1, U&&> && Constructible<T2, V&&>
-pair(U&& x , V&& y );
-
      +

      [ -San Francisco: +2009-10-15 Daniel adds: ]

      -

      -Suggested to resolve using pass-by-value for that case. -

      -

      -Side question: Should pair interoperate with tuples? Can construct a -tuple of a pair, but not a pair from a two-element tuple. -

      -

      -Related to 885. -

      +I volunteer to prepare a more fine-grained solution, but I would like +to ask for feedback that helps me doing so. If this question is asked +early in the meeting I might be able to fix it within the week, but I +cannot promise that now.

      [ -2009-07-28 Reopened by Alisdair. No longer solved by concepts. +2009-10 Santa Cruz: ]

      +
      +Leave in open. Daniel to provide wording as already suggested. +
      + +

      Proposed resolution:

      +Add the following sentence just at the end of the newly proposed +20.8.14.2 [unique.ptr.single]/p. 3:

      - -

      Rationale:

      -

      [ -San Francisco: -]

      - -
      -Solved by -N2770. +unique_ptr<T, D>::pointer's operations shall be well-formed, shall have well +defined behavior, and shall not throw exceptions.
      - -
      -

      815. std::function and reference_closure do not use perfect forwarding

      -

      Section: 20.7.16.2.4 [func.wrap.func.inv] Status: Open - Submitter: Alisdair Meredith Opened: 2008-03-16 Last modified: 2009-07-16

      +

      835. tying two streams together (correction to DR 581)

      +

      Section: 27.5.4.2 [basic.ios.members] Status: Open + Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-10-20

      +

      View other active issues in [basic.ios.members].

      +

      View all other issues in [basic.ios.members].

      View all issues with Open status.

      Discussion:

      -

      -std::function and reference_closure should use "perfect forwarding" as -described in the rvalue core proposal. -

      +

      -

      [ -Sophia Antipolis: -]

      +The fix for +issue 581, +now integrated into the working paper, overlooks a couple of minor +problems. +

      +

      -

      -According to Doug Gregor, as far as std::function is concerned, perfect -forwarding can not be obtained because of type erasure. Not everyone -agreed with this diagnosis of forwarding. -
      +First, being an unformatted function once again, flush() +is required to create a sentry object whose constructor must, among +other things, flush the tied stream. When two streams are tied +together, either directly or through another intermediate stream +object, flushing one will also cause a call to flush() on +the other tied stream(s) and vice versa, ad infinitum. The program +below demonstrates the problem. -

      [ -2009-05-01 Howard adds: -]

      +

      +

      +Second, as Bo Persson notes in his +comp.lang.c++.moderated post, +for streams with the unitbuf flag set such +as std::stderr, the destructor of the sentry object will +again call flush(). This seems to create an infinite +recursion for std::cerr << std::flush; -

      -

      -Sebastian Gesemann brought to my attention that the CopyConstructible -requirement on function's ArgTypes... is an unnecessary -restriction. -

      +

      +
      + 
      #include <iostream>
 
-
      template<Returnable R, CopyConstructible... ArgTypes>
-class function<R(ArgTypes...)>
-...
-
      
-
-
      
-On further investigation, this complaint seemed to be the same
-issue as this one.  I believe the reason CopyConstructible was put
-on ArgTypes in the first place was because of the nature of the
-invoke member:
-
      
-
-
      template<class R, class ...ArgTypes>
-R
-function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
-{
-    if (f_ == 0)
-        throw bad_function_call();
-    return (*f_)(arg...);
-}
-
      
-
-
      
-However now with rvalue-refs, "by value" no longer implies CopyConstructible
-(as Sebastian correctly points out).  If rvalue arguments are supplied, MoveConstructible
-is sufficient.  Furthermore, the constraint need not be applied in function
-if I understand correctly.  Rather the client must apply the proper constraints
-at the call site.  Therefore, at the very least, I recommend that CopyConstructible
-be removed from the template class function.
-
      
-
-
      
-Furthermore we need to mandate that the invoker is coded as:
-
      
-
-
      template<class R, class ...ArgTypes>
-R
-function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
+int main ()
 {
-    if (f_ == 0)
-        throw bad_function_call();
-    return (*f_)(std::forward<ArgTypes>(arg)...);
-}
-
      
-
-
      
-Note that ArgTypes&& (the "perfect forwarding signature") is not 
-appropriate here as this is not a deduced context for ArgTypes.  Instead
-the client's arguments must implicitly convert to the non-deduced ArgType
-type.  Catching these arguments by value makes sense to enable decay.
-
      
-
-
      
-Next forward is used to move the ArgTypes as efficiently as
-possible, and also with minimum requirements (not CopyConstructible)
-to the type-erased functor.  For object types, this will be a move.  For
-reference type ArgTypes, this will be a copy.  The end result must be
-that the following is a valid program:
-
      
-
-
      #include <functional>
-#include <memory>
-#include <cassert>
+   std::cout.tie (&std::cerr);
+   std::cerr.tie (&std::cout);
+   std::cout << "cout\n";
+   std::cerr << "cerr\n";
+} 
+
      
+
      
 
-std::unique_ptr<int>
-f(std::unique_ptr<int> p, int& i)
-{
-    ++i;
-    return std::move(p);
-}
+
      [
+Batavia (2009-05):
+]
      
 
-int main()
-{
-    int i = 2;
-    std::function<std::unique_ptr<int>(std::unique_ptr<int>,
-                                       int&> g(f);
-    std::unique_ptr<int> p = g(std::unique_ptr<int>(new int(1)), i);
-    assert(*p == 1);
-    assert(i == 3);
-}
-
      +
      +We agree with the proposed resolution. +Move to Review. +

      [ -Tested in pre-concepts rvalue-ref-enabled compiler. +2009-05-26 Daniel adds: ]

      +

      -In the example above, the first ArgType is unique_ptr<int> -and the second ArgType is int&. Both must work! +I think that the most recently suggested change in +27.7.2.4 [ostream::sentry] need some further word-smithing. As +written, it would make the behavior undefined, if under +conditions when pubsync() should be called, but when +in this scenario os.rdbuf() returns 0. +

      +

      +This case is explicitly handled in flush() and needs to be +taken care of. My suggested fix is:

      +
      +If ((os.flags() & ios_base::unitbuf) && !uncaught_exception() +&& os.rdbuf() != 0) is true, calls os.flush() +os.rdbuf()->pubsync().
      -

      [ -2009-05-27 Daniel adds: -]

      - - -

      -in the 2009-05-01 comment of above mentioned issue Howard +Two secondary questions are:

      -
        +
        1. -Recommends to replace the CopyConstructible requirement by a -MoveConstructible requirement +Should pubsync() be invoked in any case or shouldn't a +base requirement for this trial be that os.good() == true +as required in the original flush() case?
        2. -Says: "Furthermore, the constraint need not be applied in function if I -understand correctly. Rather the client must apply the proper constraints -at the call site" +Since uncaught_exception() is explicitly tested, shouldn't +a return value of -1 of pubsync() produce setstate(badbit) +(which may throw ios_base::failure)?
        -

        -I'm fine with (a), but I think comment (b) is incorrect, at least in the -sense I read these sentences. Let's look at Howard's example code: -

        - -
        function<R(ArgTypes...)>::operator()(ArgTypes... arg) const
-{
-   if (f_ == 0)
-       throw bad_function_call();
-   return (*f_)(std::forward<ArgTypes>(arg)...);
-}
-
        - -

        -In the constrained scope of this operator() overload the expression -"(*f_)(std::forward<ArgTypes>(arg)...)" must be valid. How can it -do so, if ArgTypes aren't at least MoveConstructible? -

      [ @@ -9923,196 +8075,139 @@ do so, if ArgTypes aren't at least MoveConstructible?

      -Leave this open and wait until concepts are removed from the Working -Draft so that we know how to write the proposed resolution in terms of -diffs to otherwise stable text. -
      - - - -

      Proposed resolution:

      -

      -

      - - - - - -
      -

      816. Should bind()'s returned functor have a nofail copy ctor when bind() is nofail?

      -

      Section: 20.7.12.1.3 [func.bind.bind] Status: Open - Submitter: Stephan T. Lavavej Opened: 2008-02-08 Last modified: 2009-07-16

      -

      View other active issues in [func.bind.bind].

      -

      View all other issues in [func.bind.bind].

      -

      View all issues with Open status.

      -

      Discussion:

      -

      -Library Issue 527 notes that bind(f, t1, ..., tN) -should be nofail when f, t1, ..., tN have nofail copy ctors. -

      -However, no guarantees are provided for the copy ctor of the functor -returned by bind(). (It's guaranteed to have a copy ctor, which can -throw implementation-defined exceptions: bind() returns a forwarding -call wrapper, TR1 3.6.3/2. A forwarding call wrapper is a call wrapper, -TR1 3.3/4. Every call wrapper shall be CopyConstructible, TR1 3.3/4. -Everything without an exception-specification may throw -implementation-defined exceptions unless otherwise specified, C++03 -17.4.4.8/3.) +Daniel volunteered to modify the proposed resolution to address his two questions.

      -Should the nofail guarantee requested by Library Issue 527 be extended -to cover both calling bind() and copying the returned functor? +Move back to Open.

      - -

      [ -Howard adds: -]

      - - -
      -tuple construction should probably have a similar guarantee.

      [ -San Francisco: +2009-07-26 Daniel provided wording. Moved to Review. ]

      -
      -Howard to provide wording. -
      -

      [ -Post Summit, Anthony provided wording. +2009-10-13 Daniel adds: ]

      -

      [ -Batavia (2009-05): -]

      -
      -Part of all of this issue appears to be rendered moot -by the proposed resolution to issue 817 (q.v.). -We recommend the issues be considered simultaneously -(or possibly even merged) -to ensure there is no overlap. -Move to Open, and likewise for issue 817. +This proposed wording is written to match the outcome +of 397.

      [ -2009-07 Frankfurt: +2009 Santa Cruz: ]

      -Related to 817 (see below). Leave Open. +Move to Open. Martin to propose updated wording that will also resolve +issue 397 consistently.

      Proposed resolution:

      +

      [ +based on +N2960 +numbering +]

      + + +
        +

      1. -Add a new sentence to the end of paragraphs 2 and 4 of 20.7.12.1.3 [func.bind.bind]: +Just before 27.5.4.2 [basic.ios.members]/2 insert a new paragraph:

        +Requires: If (tiestr != 0) is true, tiestr must not be reachable +by traversing the linked list of tied stream objects starting from +tiestr->tie(). +
        +
        2. + +

      2. --2- Returns: A forwarding call wrapper g with a weak result type (20.6.2). The effect of g(u1, u2, -..., uM) shall be INVOKE(f, v1, v2, ..., vN, Callable<F cv,V1, V2, ..., VN>::result_type), where cv -represents the cv-qualifiers of g and the values and types of the bound arguments -v1, v2, ..., vN are determined as specified below. -The copy constructor and move constructor of the forwarding call wrapper shall throw an -exception if and only if the corresponding constructor of F or any of the types -in BoundArgs... throw an exception. -

        -

        ...

        -

        --4- Returns: A forwarding call wrapper g with a nested type result_type defined as a synonym -for R. The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, R), where the -values and types of the bound arguments v1, v2, ..., vN are determined as specified below. -The copy constructor and move constructor of the forwarding call wrapper shall throw an -exception if and only if the corresponding constructor of F or any of the types -in BoundArgs... throw an exception. +Change 27.7.2.4 [ostream::sentry]/4 as indicated:

        +
        +If ((os.flags() & ios_base::unitbuf) && !uncaught_exception()&& +os.good()) is true, calls os.flush() +os.rdbuf()->pubsync(). If that function returns -1 sets +badbit in os.rdstate() without propagating an exception.
        +
        3. + +
      +
      -

      817. bind needs to be moved

      -

      Section: 20.7.12.1.3 [func.bind.bind] Status: Open - Submitter: Howard Hinnant Opened: 2008-03-17 Last modified: 2009-07-16

      -

      View other active issues in [func.bind.bind].

      -

      View all other issues in [func.bind.bind].

      -

      View all issues with Open status.

      +

      836. + effects of money_base::space and + money_base::none on money_get +

      +

      Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Ready + Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-10-21

      +

      View all other issues in [locale.money.get.virtuals].

      +

      View all issues with Ready status.

      +

      Duplicate of: 670

      Discussion:

      -

      Addresses US 72, JP 38 and DE 21

      -

      -The functor returned by bind() should have a move constructor that -requires only move construction of its contained functor and bound arguments. -That way move-only functors can be passed to objects such as thread. -

      -

      -This issue is related to issue 816. -

      +

      -

      -US 72: -

      +In paragraph 2, 22.4.6.1.2 [locale.money.get.virtuals] specifies the following: -
      -bind should support move-only functors and bound arguments. -
      +

      +
      -

      -JP 38: -

      +Where space or none appears in the format +pattern, except at the end, optional white space (as recognized +by ct.is) is consumed after any required space. -
      -

      -add the move requirement for bind's return type. -

      -

      -For example, assume following th1 and th2, -

      +
      +

      -

      void f(vector<int> v) { }
+This requirement can be (and has been) interpreted two mutually
+exclusive ways by different readers. One possible interpretation
+is that:
 
-vector<int> v{ ... };
-thread th1([v]{ f(v); });
-thread th2(bind(f, v));
-
      +

      +
      +
        +
      1. -

        -When function object are set to thread, v is moved to th1's lambda -expression in a Move Constructor of lambda expression because th1's lambda -expression has a Move Constructor. But bind of th2's -return type doesn't have the requirement of Move, so it may not -moved but copied. -

        -

        -Add the requirement of move to get rid of this useless copy. -

        -

        -And also, add the MoveConstructible as well as CopyConstructible. -

        -
      +where money_base::space appears in the format, at least +one space is required, and -

      -DE 21 -

      + +
    • -
      -The specification for bind claims twice that "the values and types for -the bound arguments v1, v2, ..., vN are determined as specified below". -No such specification appears to exist. -
      +where money_base::none appears in the format, space is +allowed but not required. + +
      • + +
      +

      + +The other is that: + +

      +
      + +where either money_base::space or money_base::none appears in the format, white space is optional. + +

      [ San Francisco: @@ -10120,249 +8215,214 @@ San Francisco:

      -Howard to provide wording. +Martin will revise the proposed resolution.

      [ -Post Summit Alisdair and Howard provided wording. +2009-07 Frankfurt: ]

      -Several issues are being combined in this resolution. They are all touching the -same words so this is an attempt to keep one issue from stepping on another, and -a place to see the complete solution in one place. +There is a noun missing from the proposed resolution. It's not clear +that the last sentence would be helpful, even if the word were not +missing:

      - -
        -
      1. -bind needs to be "moved". -
        2. -
      2. -20.7.12.1.3 [func.bind.bind]/p3, p6 and p7 were accidently removed from N2798. -
        3. -
      3. -Issue 929 argues for a way to pass by && for -efficiency but retain the decaying behavior of pass by value for the -thread constructor. That same solution is applicable here. -
        4. -
      +
      +In either case, any required MISSINGWORD followed by all optional whitespace (as recognized by ct.is()) is consumed.
      +

      +Strike this sentence and move to Review. +

      [ -Batavia (2009-05): +Howard: done. ]

      -
      -

      -We were going to recommend moving this issue to Tentatively Ready -until we noticed potential overlap with issue 816 (q.v.). -

      -

      -Move to Open, -and recommend both issues be considered together -(and possibly merged). -

      [ -2009-07 Frankfurt: +2009-10 Santa Cruz: ]

      -The proposed resolution uses concepts. Leave Open. +Move to Ready.
      + +

      Proposed resolution:

      +

      -

      Proposed resolution:

      -

      -Change 20.7 [function.objects] p2: -

      +I propose to change the text to make it clear that the first +interpretation is intended, that is, to make following change to +22.4.6.1.2 [locale.money.get.virtuals], p2: -
      template<CopyConstructible MoveConstructible Fn, CopyConstructible MoveConstructible... Types>
-  unspecified bind(Fn&&, Types&&...);
-template<Returnable R, CopyConstructible MoveConstructible Fn, CopyConstructible MoveConstructible... Types>
-  unspecified bind(Fn&&, Types&&...);
-
      +

      + +
      + +When money_base::space +or money_base::none appears as the last +element in the format pattern, except at the end, optional +white space (as recognized by ct.is) is consumed after +any required space. 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, ... + +
      + + + +
      +

      854. default_delete converting constructor underspecified

      +

      Section: 20.8.14.1.1 [unique.ptr.dltr.dflt] Status: Ready + Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-10-21

      +

      View all issues with Ready status.

      +

      Discussion:

      +

      +No relationship between U and T in the converting constructor for default_delete template. +

      +

      +Requirements: U* is convertible to T* and has_virtual_destructor<T>; +the latter should also become a concept. +

      +

      +Rules out cross-casting. +

      -Change 20.7.12.1.3 [func.bind.bind]: +The requirements for unique_ptr conversions should be the same as those on the deleter.

      -
      template<CopyConstructible MoveConstructible F, CopyConstructible MoveConstructible... BoundArgs>
-  unspecified bind(F&& f, BoundArgs&&... bound_args);
-
      +

      [ +Howard adds 2008-11-26: +]

      +

      -Requires: unspecified return type shall be MoveConstructible. -

      -

      --1- Requires: INVOKE(f, w1, w2, ..., wN) (20.6.2) shall be a valid expression for some values -w1, w2, ..., wN, where N == sizeof...(bound_args). +I believe we need to be careful to not outlaw the following use case, and +I believe the current proposed wording +(requires Convertible<U*, T*> && HasVirtualDestructor<T>) does so:

      + +
      #include <memory>
+
+int main()
+{
+    std::unique_ptr<int> p1(new int(1));
+    std::unique_ptr<const int> p2(move(p1));
+    int i = *p2;
+//    *p2 = i;  // should not compile
+}
+
      +

      --2- Returns: A forwarding call wrapper g with a weak result type (20.6.2). The effect of g(u1, u2, -..., uM) shall be INVOKE(f, v1, v2, ..., vN, Callable<F cv,V1, V2, ..., VN>::result_type), where cv -represents the cv-qualifiers of g and the values and types of the bound arguments -v1, v2, ..., vN are determined as specified below. +I've removed "&& HasVirtualDestructor<T>" from the +requires clause in the proposed wording.

      -

      -Throws: Nothing unless the constructor of F or of one of the types in the BoundArgs... pack expansion -throws an exception. -

      +
      -
      template<Returnable R, CopyConstructible MoveConstructible F, CopyConstructible MoveConstructible... BoundArgs>
-  unspecified bind(F&& f, BoundArgs&&... bound_args);
-
      +

      [ +Post Summit: +]

      +

      -Requires: unspecified return type shall be MoveConstructible. +Alisdair: This issue has to stay in review pending a paper constraining +unique_ptr.

      --3- Requires: INVOKE(f, w1, w2, ..., wN) shall be a valid expression for some values w1, w2, ..., -wN, where N == sizeof...(bound_args). +Consensus: We agree with the resolution, but unique_ptr needs +to be constrained, too.

      --4- Returns: A forwarding call wrapper g with a nested type result_type defined as a synonym -for R. The effect of g(u1, u2, ..., uM) shall be INVOKE(f, v1, v2, ..., vN, R), where the -values and types of the bound arguments v1, v2, ..., vN are determined as specified below. +Recommend Keep in Review.

      -

      -

      -Throws: Nothing unless the constructor of F or of one of the types in the BoundArgs... pack expansion -throws an exception. -

      -
      -

      -Let the values of bound arguments v1, v2, ..., vN and -their corresponding types V1, V2, ..., VN depend on the type of -the corresponding argument ti in bound_args in the -call to bind and the cv-qualifiers cv of the call -wrapper g as follows. Let Ti be an alias for the ith -element of the pack expansion decay<BoundArgs>::type..., -and let ti be an alias for the ith element in the function -parameter pack expansion bound_args...: -

      - -
        -
      • -if ti is of type reference_wrapper<T> the argument is -ti.get() and its type Vi is T&; -
        • -
      • -if the value of std::is_bind_expression<Ti>::value is true the argument is ti(u1, u2, ..., uM) and -its type Vi is result_of<Ti cv (U1&, U2&, ..., UM&)>::type; -
        • -
      • -if the value j of std::is_placeholder<Ti>::value is not zero the argument is std::forward<Uj>(uj) and -its type Vi is Uj&&; -
        • -
      • -otherwise the value is ti and its type Vi is Ti cv &. -
        • -
      +

      [ +Batavia (2009-05): +]

      +
      +Keep in Review status for the reasons cited.
      +

      [ +2009-07 Frankfurt: +]

      - - - -
      -

      819. rethrow_if_nested

      -

      Section: 18.8.6 [except.nested] Status: Open - Submitter: Alisdair Meredith Opened: 2008-03-25 Last modified: 2008-09-17

      -

      View other active issues in [except.nested].

      -

      View all other issues in [except.nested].

      -

      View all issues with Open status.

      -

      Discussion:

      -

      -Looking at the wording I submitted for rethrow_if_nested, I don't think I -got it quite right. -

      - +

      -The current wording says: +The proposed resolution uses concepts. Howard needs to rewrite the +proposed resolution.

      - -
      -
      template <class E> void rethrow_if_nested(const E& e);
-
      -

      -Effects: Calls e.rethrow_nested() only if e -is publicly derived from nested_exception. +Move back to Open.

      -
      -

      -This is trying to be a bit subtle, by requiring e (not E) to be publicly -derived from nested_exception the idea is that a dynamic_cast would be -required to be sure. Unfortunately, if e is dynamically but not statically -derived from nested_exception, e.rethrow_nested() is ill-formed. -

      +

      [ +2009-07-26 Howard provided rewritten proposed wording and moved to Review. +]

      +

      [ -San Francisco: +2009-10 Santa Cruz: ]

      -Alisdair was volunteered to provide wording. +Move to Ready.
      +

      Proposed resolution:

      +

      +Add after 20.8.14.1.1 [unique.ptr.dltr.dflt], p1: +

      + +
      template <class U> default_delete(const default_delete<U>& other);
+
      +
      +

      +-1- Effects: ... +

      +

      +Remarks: This constructor shall participate in overload resolution +if and only if U* is implicitly convertible to T*. +

      +
      +
      +
      -

      822. Object with explicit copy constructor no longer CopyConstructible

      -

      Section: X [utility.arg.requirements] Status: Ready - Submitter: James Kanze Opened: 2008-04-01 Last modified: 2009-07-26

      -

      View other active issues in [utility.arg.requirements].

      -

      View all other issues in [utility.arg.requirements].

      +

      860. Floating-Point State

      +

      Section: 26 [numerics] Status: Ready + Submitter: Lawrence Crowl Opened: 2008-06-23 Last modified: 2009-10-23

      +

      View all other issues in [numerics].

      View all issues with Ready status.

      Discussion:

      -I just noticed that the following program is legal in C++03, but -is forbidden in the current draft: -

      - -
      #include <vector>
-#include <iostream>
-
-class Toto
-{
-public:
-    Toto() {}
-    explicit Toto( Toto const& ) {}
-} ;
-
-int
-main()
-{
-    std::vector< Toto > v( 10 ) ;
-    return 0 ;
-}
-
      - -

      -Is this change intentional? (And if so, what is the -justification? I wouldn't call such code good, but I don't see -any reason to break it unless we get something else in return.) +There are a number of functions that affect the floating point state. +These function need to be thread-safe, but I'm unsure of the right +approach in the standard, as we inherit them from C.

      [ @@ -10371,8 +8431,30 @@ San Francisco:

      -The subgroup that looked at this felt this was a good change, but it may -already be handled by incoming concepts (we're not sure). +

      +Nick: I think we already say that these functions do not introduce data +races; see 17.6.5.6/20 +

      +

      +Pete: there's more to it than not introducing data races; are these +states maintained per thread? +

      +

      +Howard: 21.5/14 says that strtok and strerror are not required to avoid +data races, and 20.9/2 says the same about asctime, gmtime, ctime, and +gmtime. +

      +

      +Nick: POSIX has a list of not-safe functions. All other functions are +implicitly thread safe. +

      +

      +Lawrence is to form a group between meetings to attack this issue. Nick +and Tom volunteered to work with Lawrence. +

      +

      +Move to Open. +

      [ @@ -10382,77 +8464,77 @@ Post Summit:

      -Alisdair: Proposed resolution kinda funky as these tables no longer -exist. Move from direct init to copy init. Clarify with Doug, recommends -NAD. +Hans: Sane oses seem ok. Sensible thing is implementable and makes sense. +

      +

      +Nick: Default wording seems to cover this? Hole in POSIX, these +functions need to be added to list of thread-unsafe functions. +

      +

      +Lawrence: Not sufficient, not "thread-safe" per our definition, but +think of state as a thread-local variable. Need something like "these +functions only affect state in the current thread." +

      +

      +Hans: Suggest the following wording: "The floating point environment is +maintained per-thread." +

      +

      +Walter: Any other examples of state being thread safe that are not +already covered elsewhere?

      -Walter: Suggest NAD via introduction of concepts. +Have thread unsafe functions paper which needs to be updated. Should +just fold in 26.3 [cfenv] functions.

      -Recommend close as NAD. +Recommend Open. Lawrence instead suggests leaving it open until we have +suitable wording that may or may not include the thread local +commentary.

      [ -2009-07 Frankfurt: +2009-09-23 Hans provided wording. ]

      -Need to look at again without concepts. +If I understand the history correctly, Nick, as the Posix liaison, +should probably get a veto on this, since I think it came from Posix (?) +via WG14 and should probably really be addressed there (?). But I think +we are basically in agreement that there is no other sane way to do +this, and hence we don't have to worry too much about stepping on toes. +As far as I can tell, this same issue also exists in the latest Posix +standard (?).

      [ -2009-07 Frankfurt: +2009-10 Santa Cruz: ]

      -

      -Move to Ready with original proposed resolution. -

      -

      [Howard: Original proposed resolution restored.]

      - +Moved to Ready.

      Proposed resolution:

      -In X [utility.arg.requirements] change Table 33: MoveConstructible requirements [moveconstructible]: +Add at the end of 26.3.1 [cfenv.syn]:

      - - - - - - - - - - -
      expressionpost-condition
      T t(rv) = rvt is equivalent to the value of rv before the construction
      ...
      -
      -

      -In X [utility.arg.requirements] change Table 34: CopyConstructible requirements [copyconstructible]: +2 The header defines all functions, types, and macros the same as C99 7.6.

      -
      - - - - - - - - - - -
      expressionpost-condition
      T t(u) = uthe value of u is unchanged and is equivalent to t
      ...
      +

      +A separate floating point environment shall be maintained for each +thread. Each function accesses the environment corresponding to its +calling thread. +

      @@ -10460,141 +8542,53 @@ In X [utility.arg.requirements] change Table 34: CopyConstructible requ
      -

      823. identity<void> seems broken

      -

      Section: 20.3.2 [forward] Status: Open - Submitter: Walter Brown Opened: 2008-04-09 Last modified: 2009-07-30

      -

      View other active issues in [forward].

      -

      View all other issues in [forward].

      +

      861. Incomplete specification of EqualityComparable for std::forward_list

      +

      Section: 23.2 [container.requirements] Status: Open + Submitter: Daniel Krügler Opened: 2008-06-24 Last modified: 2009-10-24

      +

      View other active issues in [container.requirements].

      +

      View all other issues in [container.requirements].

      View all issues with Open status.

      Discussion:

      -N2588 seems to have added an operator() member function to the -identity<> helper in 20.3.2 [forward]. I believe this change makes it no -longer possible to instantiate identity<void>, as it would require -forming a reference-to-void type as this operator()'s parameter type. -

      - -

      -Suggested resolution: Specialize identity<void> so as not to require -the member function's presence. +Table 89, Container requirements, defines operator== in terms of the container +member function size() and the algorithm std::equal:

      -

      [ -Sophia Antipolis: -]

      - -
      +== is an equivalence relation. a.size() == b.size() && +equal(a.begin(), a.end(), b.begin() +
      +

      -Jens: suggests to add a requires clause to avoid specializing on void. -

      -

      -Alisdair: also consider cv-qualified void. +The new container forward_list does not provide a size member function +by design but does provide operator== and operator!= without specifying it's semantic.

      -Alberto provided proposed wording. +Other parts of the (sequence) container requirements do also depend on +size(), e.g. empty() +or clear(), but this issue explicitly attempts to solve the missing +EqualityComparable specification, +because of the special design choices of forward_list.

      -
      - -

      [ -2009-07-30 Daniel reopens: -]

      - - -

      -This issue became closed, because the ReferentType requirement -fixed the problem - this is no longer the case. In retrospective it seems -to be that the root of current issues around std::identity (823, 700, -939) -is that it was standardized as something very different (an unconditional -type mapper) than traditional usage indicated (a function object that should -derive from std::unary_function), as the SGI definition does. This issue could -be solved, if std::identity is removed (one proposal of 939), but until this -has been decided, this issue should remain open. An alternative for -removing it, would be, to do the following: +I propose to apply one of the following resolutions, which are described as:

      -
        +
        1. -

          -Let identity stay as a real function object, which would -now properly -derive from unary_function: -

          - -
          template <class T> struct identity : unary_function<T, T> {
-  const T& operator()(const T&) const;
-};
-
          +Provide a definition, which is optimal for this special container without +previous size test. This choice prevents two O(N) calls of std::distance() +with the corresponding container ranges and instead uses a special +equals implementation which takes two container ranges instead of 1 1/2.
          2. -
        2. -

          -Invent (if needed) a generic type wrapper (corresponding to concept -IdentityOf), -e.g. identity_of, and move it's prototype description back to 20.3.2 [forward]: -

          - -
          template <class T> struct identity_of {
-  typedef T type;
-};
-
          - -

          -and adapt the std::forward signature to use identity_of -instead of identity. -

          +The simple fix where the usual test is adapted such that size() is replaced +by distance with corresponding performance disadvantages.
        -
      - - -

      Proposed resolution:

      -

      -Change definition of identity in 20.3.2 [forward], paragraph 2, to: -

      - -
      template <class T>  struct identity {
-    typedef T type;
-
-    requires ReferentType<T>
-      const T& operator()(const T& x) const;
-  };
-
      -

      ...

      -
        requires ReferentType<T>
-    const T& operator()(const T& x) const;
-
      - - -

      Rationale:

      -

      -The point here is to able to write T& given T and ReferentType is -precisely the concept that guarantees so, according to N2677 -(Foundational concepts). Because of this, it seems preferable than an -explicit check for cv void using SameType/remove_cv as it was suggested -in Sophia. In particular, Daniel remarked that there may be types other -than cv void which aren't referent types (int[], perhaps?). -

      - - - - - -
      -

      827. constexpr shared_ptr::shared_ptr()?

      -

      Section: 20.8.10.2.1 [util.smartptr.shared.const] Status: Open - Submitter: Peter Dimov Opened: 2008-04-11 Last modified: 2009-07-21

      -

      View other active issues in [util.smartptr.shared.const].

      -

      View all other issues in [util.smartptr.shared.const].

      -

      View all issues with Open status.

      -

      Discussion:

      -Would anyone object to making the default constructor of shared_ptr (and -weak_ptr and enable_shared_from_this) constexpr? This would enable -static initialization for shared_ptr variables, eliminating another -unfair advantage of raw pointers. +Both proposal choices are discussed, the preferred choice of the author is +to apply (A).

      [ @@ -10604,834 +8598,689 @@ San Francisco:

      -It's not clear to us that you can initialize a pointer with the literal -0 in a constant expression. We need to ask CWG to make sure this works. -Bjarne has been appointed to do this. +There's an Option C: change the requirements table to use distance(). +

      +

      +LWG found Option C acceptable.

      -Core got back to us and assured as that nullptr would do the job -nicely here. +Martin will draft the wording for Option C.

      [ -2009-05-01 Alisdair adds: +post San Francisco: ]

      -

      -I don't believe that constexpr will buy anything in this case. -shared_ptr/weak_ptr/enable_shared_from_this cannot be literal types as they -have a non-trivial copy constructor. As they do not produce literal types, -then the constexpr default constructor will not guarantee constant -initialization, and so not buy the hoped for optimization. -

      -

      -I recommend referring this back to Core to see if we can get static -initialization for types with constexpr constructors, even if they are not -literal types. Otherwise this should be closed as NAD. -

      +Martin provided wording for Option C.

      [ -2009-05-26 Daniel adds: -]

      - - -
      -If Alisdair's 2009-05-01 comment is correct, wouldn't that also make -constexpr mutex() useless, because this class has a non-trivial -destructor? (828) -
      - -

      [ -2009-07-21 Alisdair adds: +2009-07 Frankfurt ]

      -The feedback from core is that this and similar uses of constexpr -constructors to force static initialization should be supported. If -there are any problems with this in the working draught, we should file -core issues. +Other operational semantics (see, for example, Tables 82 and 83) are +written in terms of a container's size() member. Daniel to update +proposed resolution C.

      +

      [ +Howard: Commented out options A and B. +]

      -

      -Recommend we declare the default constructor constexpr as the issue suggests -(proposed wording added). -

      +

      [ +2009-07-26 Daniel updated proposed resolution C. +]

      -

      Proposed resolution:

      -

      -Change 20.8.10.2 [util.smartptr.shared] and 20.8.10.2.1 [util.smartptr.shared.const]: -

      - -
      consexpr shared_ptr();
-
      +

      [ +2009-10 Santa Cruz: +]

      -

      -Change 20.8.10.3 [util.smartptr.weak] and 20.8.10.3.1 [util.smartptr.weak.const]: -

      -
      consexpr weak_ptr();
-
      +
      +Mark NAD Editorial. Addressed by +N2986. +
      -

      -Change 20.8.10.5 [util.smartptr.enab] (2 places): -

      +

      [ +2009-10 Santa Cruz: +]

      -
      consexpr enable_shared_from_this();
-
      +
      +Reopened. +N2986 +was rejected in full committee on procedural grounds. +
      +

      Proposed resolution:

      -
      -

      828. Static initialization for std::mutex?

      -

      Section: 30.4.1.1 [thread.mutex.class] Status: Review - Submitter: Peter Dimov Opened: 2008-04-18 Last modified: 2009-05-30

      -

      View other active issues in [thread.mutex.class].

      -

      View all other issues in [thread.mutex.class].

      -

      View all issues with Review status.

      -

      Discussion:

      -

      -[Note: I'm assuming here that 3.6.2 [basic.start.init]/1 will be fixed.] -

      -Currently std::mutex doesn't support static initialization. This is a -regression with respect to pthread_mutex_t, which does. I believe that -we should strive to eliminate such regressions in expressive power where -possible, both to ease migration and to not provide incentives to (or -force) people to forego the C++ primitives in favor of pthreads. +Option (C):

      +

      [ -Sophia Antipolis: +The changes are relative to +N2914 +but concept-free. ]

      -
      +
        +

      1. -We believe this is implementable on POSIX, because the initializer-list -feature and the constexpr feature make this work. Double-check core -language about static initialization for this case. Ask core for a core -issue about order of destruction of statically-initialized objects wrt. -dynamically-initialized objects (should come afterwards). Check -non-POSIX systems for implementability. +In 23.2.1 [container.requirements.general] change Table 80 -- Container requirements as indicated:

        + +
          +

        1. -If ubiquitous implementability cannot be assured, plan B is to introduce -another constructor, make this constexpr, which is -conditionally-supported. To avoid ambiguities, this new constructor needs -to have an additional parameter. +Change the text in the Assertion/note column in the row for "X u;" +as follows:

          -
      - -

      [ -Post Summit: -]

      -
      +post: u.size() == 0empty() == true +
      + + +

    • -Jens: constant initialization seems to be ok core-language wise -

      -

      -Consensus: Defer to threading experts, in particular a Microsoft platform expert. -

      -

      -Lawrence to send e-mail to Herb Sutter, Jonathan Caves, Anthony Wiliams, -Paul McKenney, Martin Tasker, Hans Boehm, Bill Plauger, Pete Becker, -Peter Dimov to alert them of this issue. -

      -

      -Lawrence: What about header file shared with C? The initialization -syntax is different in C and C++. +Change the text in the Assertion/note column in the row for "X();" +as follows:

      + +
      +X().size() == 0empty() == true +
      +
      • + +

    • -Recommend Keep in Review +Change the text in the Operational Semantics column in the row for +"a == b" as follows:

      +
      +== is an equivalence relation. +a.size()distance(a.begin(), a.end()) == + b.size()distance(b.begin(), b.end()) && +equal(a.begin(), a.end(), b.begin())
      +
      • -

      [ -Batavia (2009-05): -]

      +
    • +

      +Change the text in the Operational Semantics column in the row for +"a.size()" as follows: +

      -Keep in Review status pending feedback from members of the Concurrency subgroup. +a.end() - a.begin()distance(a.begin(), a.end())
      +
      • -

      [ -See related comments from Alisdiar and Daniel in 827. -]

      +
    • +

      +Change the text in the Operational Semantics column in the row for +"a.max_size()" as follows: +

      +
      +size()distance(begin(), end()) of the largest +possible container +
      +
      • +
    • +

      +Change the text in the Operational Semantics column in the row for +"a.empty()" as follows: +

      +
      +a.size() == 0a.begin() == a.end() +
      +
      • + + -

      Proposed resolution:

      +

    • -Change 30.4.1.1 [thread.mutex.class]: +In 23.2.1 [container.requirements.general] change Table 82 -- Allocator-aware container requirements as indicated:

      -
      class mutex {
-public:
-  constexpr mutex();
-  ...
-
      - +
        +
      1. +

        +Change the text in the Assertion/note column in the row for "X() / +X u;" as follows: +

        +
        +Requires: A is DefaultConstructible post: u.size() == +0u.empty() == true, get_allocator() == A() +
        +
        2. +
      2. +

        +Change the text in the Assertion/note column in the row for "X(m) / +X u(m);" as follows: +

        +
        +post: u.size() == 0u.empty() == true, +get_allocator() == m +
        +
        3. +
      +
      • -
      -

      834. Unique_ptr::pointer requirements underspecified

      -

      Section: 20.8.9.2 [unique.ptr.single] Status: Ready - Submitter: Daniel Krügler Opened: 2008-05-14 Last modified: 2009-07-16

      -

      View other active issues in [unique.ptr.single].

      -

      View all other issues in [unique.ptr.single].

      -

      View all issues with Ready status.

      -

      Discussion:

      +

    • -Issue 673 (including recent updates by 821) proposes a useful -extension point for unique_ptr by granting support for an optional -deleter_type::pointer to act as pointer-like replacement for element_type* -(In the following: pointer). +In 23.2.3 [sequence.reqmts] change Table 83 -- Sequence container requirements as indicated:

      + +
        +

      1. -Unfortunately no requirements are specified for the type pointer which has -impact on at least two key features of unique_ptr: +Change the text in the Assertion/note column in the row for "X(n, +t) / X a(n, t)" as follows:

        -
          -
        1. Operational fail-safety.
          2. -
        2. (Well-)Definedness of expressions.
          3. -
        +
        +post: size()distance(begin(), end()) == n [..] +
        +
        2. +

      2. -Unique_ptr specification makes great efforts to require that essentially *all* -operations cannot throw and therefore adds proper wording to the affected -operations of the deleter as well. If user-provided pointer-emulating types -("smart pointers") will be allowed, either *all* throw-nothing clauses have to -be replaced by weaker "An exception is thrown only if pointer's {op} throws -an exception"-clauses or it has to be said explicitly that all used -operations of -pointer are required *not* to throw. I understand the main focus of unique_ptr -to be as near as possible to the advantages of native pointers which cannot -fail and thus strongly favor the second choice. Also, the alternative position -would make it much harder to write safe and simple template code for -unique_ptr. Additionally, I assume that a general statement need to be given -that all of the expressions of pointer used to define semantics are required to -be well-formed and well-defined (also as back-end for 762). +Change the text in the Assertion/note column in the row for "X(i, +j) / X a(i, j)" as follows:

        -

        [ -Sophia Antipolis: -]

        - -
        +[..] post: size() == distance between i and +jdistance(begin(), end()) == distance(i, j) [..] +
        +
        3. + +

      3. -Howard: We maybe need a core concept PointerLike, but we don't need the -arithmetic (see shared_ptr vs. vector<T>::iterator. +Change the text in the Assertion/note column in the row for +"a.clear()" as follows:

        +
        +a.erase(a.begin(), a.end()) post: +size() == 0a.empty() == true +
        +
        4. +
      +
      • + +

    • -Howard will go through and enumerate the individual requirements wrt. pointer for each member function. +In 23.2.4 [associative.reqmts] change Table 85 -- Associative container requirements as indicated:

      -

      • [ -2009-07 Frankfurt: +Not every occurrence of size() was replaced, because all current +associative containers +have a size. The following changes ensure consistency regarding the +semantics of "erase" +for all tables and adds some missing objects ]

      +
        +
      1. +

        +Change the text in the Complexity column in the row for +"a.insert(i, j)" as follows: +

        -Move to Ready. +N log(a.size() + N) (N is the distance from i to +j) where N == distance(i, j)
        +
        2. - - -

        Proposed resolution:

        +

      2. -Add the following sentence just at the end of the newly proposed -20.8.9.2 [unique.ptr.single]/p. 3: +Change the text in the Complexity column in the row for +"a.erase(k)" as follows:

        -
        -unique_ptr<T, D>::pointer's operations shall be well-formed, shall have well -defined behavior, and shall not throw exceptions. +log(a.size()) + a.count(k)
        +
        3. +
      3. +

        +Change the text in the Complexity column in the row for +"a.erase(q1, q2)" as follows: +

        +
        +log(a.size()) + N where N is the distance from q1 +to q2 + == distance(q1, q2). +
        +
        4. +
      4. +

        +Change the text in the Assertion/note column in the row for +"a.clear()" as follows: +

        +
        +a.erase(a.begin(),a.end()) post: size() == +0a.empty() == true +
        +
        5. -
        -

        835. tying two streams together (correction to DR 581)

        -

        Section: 27.5.4.2 [basic.ios.members] Status: Review - Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-07-27

        -

        View other active issues in [basic.ios.members].

        -

        View all other issues in [basic.ios.members].

        -

        View all issues with Review status.

        -

        Discussion:

        -

        - -The fix for -issue 581, -now integrated into the working paper, overlooks a couple of minor -problems. - -

        -

        - -First, being an unformatted function once again, flush() -is required to create a sentry object whose constructor must, among -other things, flush the tied stream. When two streams are tied -together, either directly or through another intermediate stream -object, flushing one will also cause a call to flush() on -the other tied stream(s) and vice versa, ad infinitum. The program -below demonstrates the problem. - -

        -

        - -Second, as Bo Persson notes in his -comp.lang.c++.moderated post, -for streams with the unitbuf flag set such -as std::stderr, the destructor of the sentry object will -again call flush(). This seems to create an infinite -recursion for std::cerr << std::flush; - -

        -
        - 
        #include <iostream>
+
      5. 
+
        
+Change the text in the Complexity column in the row for "a.clear()"
+as follows:
+
        
 
-int main ()
-{
-   std::cout.tie (&std::cerr);
-   std::cerr.tie (&std::cout);
-   std::cout << "cout\n";
-   std::cerr << "cerr\n";
-} 
-
        6. +
        +linear in a.size()
        + -

        [ -Batavia (2009-05): -]

        +
      6. +

        +Change the text in the Complexity column in the row for +"a.count(k)" as follows: +

        -We agree with the proposed resolution. -Move to Review. +log(a.size()) + a.count(k)
        +
        7. +
      + +
    • +

      +In 23.2.5 [unord.req] change Table 87 -- Unordered associative container requirements as indicated: +

      [ -2009-05-26 Daniel adds: +The same rational as for Table 85 applies here ]

      -
      -

      -I think that the most recently suggested change in -27.7.2.4 [ostream::sentry] need some further word-smithing. As -written, it would make the behavior undefined, if under -conditions when pubsync() should be called, but when -in this scenario os.rdbuf() returns 0. -

      +
        +

      1. -This case is explicitly handled in flush() and needs to be -taken care of. My suggested fix is: +Change the text in the Assertion/note column in the row for +"a.clear()" as follows:

        -If ((os.flags() & ios_base::unitbuf) && !uncaught_exception() -&& os.rdbuf() != 0) is true, calls os.flush() -os.rdbuf()->pubsync(). +[..] Post: a.size() == 0empty() == true +
        +
        2. +
      +
      • + + +
      + + + + +
      +

      865. More algorithms that throw away information

      +

      Section: 25.3.6 [alg.fill], 25.3.7 [alg.generate] Status: Ready + Submitter: Daniel Krügler Opened: 2008-07-13 Last modified: 2009-10-23

      +

      View all issues with Ready status.

      +

      Discussion:

      -Two secondary questions are: +In regard to library defect 488 I found some more algorithms which +unnecessarily throw away information. These are typically algorithms, +which sequentially write into an OutputIterator, but do not return the +final value of this output iterator. These cases are:

      1. -Should pubsync() be invoked in any case or shouldn't a -base requirement for this trial be that os.good() == true -as required in the original flush() case? -
        2. +
        template<class OutputIterator, class Size, class T>
+void fill_n(OutputIterator first, Size n, const T& value);
        +
      2. -Since uncaught_exception() is explicitly tested, shouldn't -a return value of -1 of pubsync() produce setstate(badbit) -(which may throw ios_base::failure)? -
        3. +
        template<class OutputIterator, class Size, class Generator>
+void generate_n(OutputIterator first, Size n, Generator gen);
      -
      +

      +In both cases the minimum requirements on the iterator are +OutputIterator, which means according to the requirements of +24.2.2 [output.iterators]/2 that only single-pass iterations are guaranteed. +So, if users of fill_n and generate_n have *only* an OutputIterator +available, they have no chance to continue pushing further values +into it, which seems to be a severe limitation to me. +

      [ -2009-07 Frankfurt: +Post Summit Daniel "conceptualized" the wording. ]

      +

      [ +Batavia (2009-05): +]

      +

      -Daniel volunteered to modify the proposed resolution to address his two questions. +Alisdair likes the idea, but has concerns about the specific wording +about the returns clauses.

      -Move back to Open. +Alan notes this is a feature request. +

      +

      +Bill notes we have made similar changes to other algorithms. +

      +

      +Move to Open.

      [ -2009-07-26 Daniel provided wording. Moved to Review. +2009-07 Frankfurt ]

      +
      +We have a consensus for moving forward on this issue, but Daniel needs +to deconceptify it. +
      + +

      [ +2009-07-25 Daniel provided non-concepts wording. +]

      -

      Proposed resolution:

      [ -based on -N2914 -numbering +2009-10 Santa Cruz: ]

      +
      +Moved to Ready. +
      + + + +

      Proposed resolution:

      +

      1. -Just before 27.5.4.2 [basic.ios.members]/2 insert a new paragraph: +Replace the current declaration of fill_n in 25 [algorithms]/2, header +<algorithm> synopsis and in 25.3.6 [alg.fill] by +

        + +
        template<class OutputIterator, class Size, class T>
+  voidOutputIterator fill_n(OutputIterator first, Size n, const T& value);
+
        + +

        +Just after the effects clause add a new returns clause saying:

        -Requires: If (tiestr != 0) is true, tiestr must not be reachable -by traversing the linked list of tied stream objects starting from -tiestr->tie(). +Returns: For fill_n and positive n, returns first + n. Otherwise +returns first for fill_n.

      2. -Change 27.7.2.4 [ostream::sentry]/4 as indicated: +Replace the current declaration of generate_n in 25 [algorithms]/2, +header <algorithm> synopsis and in 25.3.7 [alg.generate] by +

        + +
        template<class OutputIterator, class Size, class Generator>
+  voidOutputIterator generate_n(OutputIterator first, Size n, Generator gen);
+
        + +

        +Just after the effects clause add a new returns clause saying:

        -If ((os.flags() & ios_base::unitbuf) && !uncaught_exception()&& -os.good()) is true, calls os.flush() -os.rdbuf()->pubsync(). If that function returns -1 sets -badbit in os.rdstate() without propagating an exception. +For generate_n and positive n, returns first + n. Otherwise +returns first for generate_n.
        3. -
      - + +
      -

      836. - effects of money_base::space and - money_base::none on money_get -

      -

      Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: Review - Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-07-16

      -

      View other active issues in [locale.money.get.virtuals].

      -

      View all other issues in [locale.money.get.virtuals].

      -

      View all issues with Review status.

      -

      Duplicate of: 670

      +

      868. default construction and value-initialization

      +

      Section: 23 [containers] Status: Ready + Submitter: Alberto Ganesh Barbati Opened: 2008-07-22 Last modified: 2009-10-20

      +

      View other active issues in [containers].

      +

      View all other issues in [containers].

      +

      View all issues with Ready status.

      Discussion:

      +

      +The term "default constructed" is often used in wording that predates +the introduction of the concept of value-initialization. In a few such +places the concept of value-initialization is more correct than the +current wording (for example when the type involved can be a built-in) +so a replacement is in order. Two of such places are already covered by +issue 867. This issue deliberately addresses the hopefully +non-controversial changes in the attempt of being approved more quickly. +A few other occurrences (for example in std::tuple, +std::reverse_iterator and std::move_iterator) are left to separate +issues. For std::reverse_iterator, see also issue 408. This issue is +related with issue 724. +

      -

      +

      [ +San Francisco: +]

      -In paragraph 2, 22.4.6.1.2 [locale.money.get.virtuals] specifies the following: -

      -
      - -Where space or none appears in the format -pattern, except at the end, optional white space (as recognized -by ct.is) is consumed after any required space. - -
      -

      - -This requirement can be (and has been) interpreted two mutually -exclusive ways by different readers. One possible interpretation -is that: - -

      -
      -
        -
      1. - -where money_base::space appears in the format, at least -one space is required, and - -
        2. -
      2. - -where money_base::none appears in the format, space is -allowed but not required. - -
        3. -
      -
      -

      - -The other is that: - -

      -
      - -where either money_base::space or money_base::none appears in the format, white space is optional. - -
      +
      +

      +The list provided in the proposed resolution is not complete. James +Dennett will review the library and provide a complete list and will +double-check the vocabulary. +

      +

      +This issue relates to Issue 886 tuple construction +

      +

      [ -San Francisco: +2009-07 Frankfurt ]

      -Martin will revise the proposed resolution. +

      +The proposed resolution is incomplete. +

      +

      +Move to Tentatively NAD Future. Howard will contact Ganesh for wording. +If wording is forthcoming, Howard will move it back to Review. +

      [ -2009-07 Frankfurt: +2009-07-18 Ganesh updated the proposed wording. ]

      -There is a noun missing from the proposed resolution. It's not clear -that the last sentence would be helpful, even if the word were not -missing: +Howard: Moved back to Review. Note that 20.2.1 [utility.arg.requirements] +refers to a section that is not in the current working paper, but does refer to +a section that we expect to reappear after the de-concepts merge. This was a +point of confusion we did not recognize when we reviewed this issue in Frankfurt.

      -
      -In either case, any required MISSINGWORD followed by all optional whitespace (as recognized by ct.is()) is consumed. -

      -Strike this sentence and move to Review. +Howard: Ganesh also includes a survey of places in the WP surveyed for changes +of this nature and purposefully not treated:

      -
      - - - -

      Proposed resolution:

      -

      - -I propose to change the text to make it clear that the first -interpretation is intended, that is, to make following change to -22.4.6.1.2 [locale.money.get.virtuals], p2: - -

      - -
      - -When money_base::space -or money_base::none appears as the last -element in the format pattern, except at the end, optional -white space (as recognized by ct.is) is consumed after -any required space. 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, ... - -
      - - - - -
      -

      838. - can an end-of-stream iterator become a non-end-of-stream one? -

      -

      Section: 24.6.1 [istream.iterator] Status: Ready - Submitter: Martin Sebor Opened: 2008-05-17 Last modified: 2009-07-16

      -

      View other active issues in [istream.iterator].

      -

      View all other issues in [istream.iterator].

      -

      View all issues with Ready status.

      -

      Discussion:

      -

      - -From message c++std-lib-20003... - -

      -

      - -The description of istream_iterator in -24.6.1 [istream.iterator], p1 specifies that objects of the -class become the end-of-stream (EOS) iterators under the -following condition (see also issue 788 another problem -with this paragraph): - -

      -
      - -If the end of stream is reached (operator void*() on the -stream returns false), the iterator becomes equal to -the end-of-stream iterator value. - -
      -

      - -One possible implementation approach that has been used in practice is -for the iterator to set its in_stream pointer to 0 when -it reaches the end of the stream, just like the default ctor does on -initialization. The problem with this approach is that -the Effects clause for operator++() says the -iterator unconditionally extracts the next value from the stream by -evaluating *in_stream >> value, without checking -for (in_stream == 0). - -

      -

      - -Conformance to the requirement outlined in the Effects clause -can easily be verified in programs by setting eofbit -or failbit in exceptions() of the associated -stream and attempting to iterate past the end of the stream: each -past-the-end access should trigger an exception. This suggests that -some other, more elaborate technique might be intended. - -

      -

      - -Another approach, one that allows operator++() to attempt -to extract the value even for EOS iterators (just as long -as in_stream is non-0) is for the iterator to maintain a -flag indicating whether it has reached the end of the stream. This -technique would satisfy the presumed requirement implied by -the Effects clause mentioned above, but it isn't supported by -the exposition-only members of the class (no such flag is shown). This -approach is also found in existing practice. - -

      -

      - -The inconsistency between existing implementations raises the question -of whether the intent of the specification is that a non-EOS iterator -that has reached the EOS become a non-EOS one again after the -stream's eofbit flag has been cleared? That is, are the -assertions in the program below expected to pass? - -

      -
      - 
         sstream strm ("1 ");
-   istream_iterator eos;
-   istream_iterator it (strm);
-   int i;
-   i = *it++
-   assert (it == eos);
-   strm.clear ();
-   strm << "2 3 ";
-   assert (it != eos);
-   i = *++it;
-   assert (3 == i);
-
      -
      -

      - -Or is it intended that once an iterator becomes EOS it stays EOS until -the end of its lifetime? - -

      - -

      [ -San Francisco: -]

      -

      -We like the direction of the proposed resolution. We're not sure about -the wording, and we need more time to reflect on it, +Places where changes are not being +proposed

      -Move to Open. Detlef to rewrite the proposed resolution in such a way -that no reference is made to exposition only members of -istream_iterator. +In the following paragraphs, we are not proposing changes because +it's not clear whether we actually prefer value-initialization over +default-initialization (now partially covered by 1012):

      +
        +

      • 20.8.14.2.1 [unique.ptr.single.ctor] para 3 e 7

        • +

      • 24.5.1.3.1 [reverse.iter.cons] para 1

        • +

      • 24.5.3.3.1 [move.iter.op.const] para 1

        • +
      +

      In the following paragraphs, the expression "default +constructed" need not be changed, because the relevant type does +not depend on a template parameter and has a user-provided +constructor:

      +
        +

      • [func.referenceclosure.invoke] para 12, type: + reference_closure

        • +

      • 30.3.1.2 [thread.thread.constr] para 30, type: thread

        • +

      • 30.3.1.5 [thread.thread.member] para 52, type: thread_id

        • +

      • 30.3.2 [thread.thread.this], para 1, type: thread_id

        • +
      +
      +

      [ -2009-07 Frankfurt: +2009-08-18 Daniel adds: ]

      -Move to Ready. -
      - - - -

      Proposed resolution:

      -

      - -The discussion of this issue on the reflector suggests that the intent -of the standard is for an istreambuf_iterator that has -reached the EOS to remain in the EOS state until the end of its -lifetime. Implementations that permit EOS iterators to return to a -non-EOS state may only do so as an extension, and only as a result of -calling istream_iterator member functions on EOS -iterators whose behavior is in this case undefined. - -

      -

      - -To this end we propose to change 24.6.1 [istream.iterator], p1, -as follows: - -

      -
      - -The result of operator-> on an end-of-stream -is not defined. For any other iterator value a const T* -is returned. Invoking operator++() on -an end-of-stream iterator is undefined. It is impossible -to store things into istream iterators... - -
      -

      - -Add pre/postconditions to the member function descriptions of istream_iterator like so: - -

      -
      - -
      istream_iterator();
      - -Effects: Constructs the end-of-stream iterator.
      -Postcondition: in_stream == 0. - -
      istream_iterator(istream_type &s);
      - -Effects: Initializes in_stream with &s. value -may be initialized during construction or the first time it is -referenced.
      -Postcondition: in_stream == &s. - -
      istream_iterator(const istream_iterator &x);
      - -Effects: Constructs a copy of x.
      -Postcondition: in_stream == x.in_stream. - -
      istream_iterator& operator++();
      - -Requires: in_stream != 0.
      -Effects: *in_stream >> value. - -
      istream_iterator& operator++(int);
      - -Requires: in_stream != 0.
      -Effects: - 
      istream_iterator tmp (*this);
-*in_stream >> value;
-return tmp;
-
      -
      -
      - - - +

      +I have no objections against the currently suggested changes, but I +also cross-checked +with the list regarding intentionally excluded changes, and from this +I miss the discussion +of +

      -
      -

      847. string exception safety guarantees

      -

      Section: 21.4.1 [string.require] Status: Ready - Submitter: Hervé Brönnimann Opened: 2008-06-05 Last modified: 2009-07-16

      -

      View all other issues in [string.require].

      -

      View all issues with Ready status.

      -

      Discussion:

      +
        +

      1. -In March, on comp.lang.c++.moderated, I asked what were the -string exception safety guarantees are, because I cannot see -*any* in the working paper, and any implementation I know offers -the strong exception safety guarantee (string unchanged if a -member throws exception). The closest the current draft comes to -offering any guarantees is 21.4 [basic.string], para 3: +21.4.1 [string.require]/2:

        -The class template basic_string conforms to the requirements -for a Sequence Container (23.1.1), for a Reversible Container (23.1), -and for an Allocator-aware container (91). The iterators supported by -basic_string are random access iterators (24.1.5). +"[..] The Allocator object used shall be a copy of the Allocator> +object passed to the basic_string object's +constructor or, if the constructor does not take an Allocator +argument, a copy of a default-constructed +Allocator object."
        +
        2. +

      2. -However, the chapter 23 only says, on the topic of exceptions: 23.2 [container.requirements], -para 10: +N2723, +X [rand.req.eng], Table 109, expression "T()":

        -
        -

        -Unless otherwise specified (see 23.2.2.3 and 23.2.6.4) all container types defined in this clause meet the following -additional requirements: -

        - -
          -
        • if an exception is thrown by...
          • -
        +Pre-/post-condition: "Creates an engine with the same initial state as +all other default-constructed engines of type X."

        -I take it as saying that this paragraph has *no* implication on -std::basic_string, as basic_string isn't defined in Clause 23 and -this paragraph does not define a *requirement* of Sequence -nor Reversible Container, just of the models defined in Clause 23. -In addition, LWG Issue 718 proposes to remove 23.2 [container.requirements], para 3. +as well as in 26.5.5 [rand.predef]/1-9 (N2914), 26.5.7.1 [rand.util.seedseq]/3, 27.7.1.1.1 [istream.cons]/3, 27.7.2.2 [ostream.cons]/9 (N2914), 28.13 [re.grammar]/2, 30.3.1.4 [thread.thread.assign]/1 (N2914),

        +

        [ +Candidates for the "the expression "default constructed" need not be +changed" list +]

        +

        -Finally, the fact that no operation on Traits should throw -exceptions has no bearing, except to suggest (since the only -other throws should be allocation, out_of_range, or length_error) -that the strong exception guarantee can be achieved. +I'm fine, if these would be added to the intentionally exclusion list, +but mentioning them makes it +easier for other potential reviewers to decide on the relevance or +not-relevance of them for this issue.

        +
        3. +

      3. -The reaction in that group by Niels Dekker, Martin Sebor, and -Bo Persson, was all that this would be worth an LWG issue. +I suggest to remove the reference of [func.referenceclosure.invoke] +in the "it's not clear" list, because +this component does no longer exist.

        +
        4. +

      4. -A related issue is that erase() does not throw. This should be -stated somewhere (and again, I don't think that the 23.2 [container.requirements], para 1 -applies here). +I also suggest to add a short comment that all paragraphs in the +resolution whether they refer to N2723 or to N2914 numbering, because e.g. "Change 23.3.2.1 [deque.cons] para 5" is an N2723 coordinate, while "Change 23.3.2.2 [deque.capacity] para 1" is an N2914 coordinate. Even better would be to use one default document +for the numbering (probably N2914) and mention special cases (e.g. "Change 20.2.1 [utility.arg.requirements] para 2" as referring to N2723 numbering).

        +
        5. +
      -

      [ -San Francisco: -]

      - - -
      -Implementors will study this to confirm that it is actually possible.

      [ -Daniel adds 2009-02-14: +2009-08-18 Alisdair adds: ]

      -The proposed resolution of paper -N2815 -interacts with this issue (the paper does not refer to this issue). +

      +I strongly believe the term "default constructed" should not appear in +the library clauses unless we very clearly define a meaning for it, and +I am not sure what that would be. +

      + +

      +In those cases where we do not want to replace "default constructed" +with "vale initialized" we should be using "default initialized". If we +have a term that could mean either, we reduce portability of programs. +

      + +

      +I have not done an exhaustive review to clarify if that is a vendor +freedom we have reason to support (e.g. value-init in debug, +default-init in release) so I may yet be convinced that LWG has reason +to define this new term of art, but generally C++ initialization is +confusing enough without supporting further ill-defined terms. +

      [ -2009-07 Frankfurt: +2009-10 Santa Cruz: ]

      @@ -11443,346 +9292,330 @@ Move to Ready.

      Proposed resolution:

      -Add a blanket statement in 21.4.1 [string.require]: +Change 20.2.1 [utility.arg.requirements] para 2:

      -

      -- if any member function or operator of basic_string<charT, traits, Allocator> -throws, that function or operator has no effect. -

      -

      -- no erase() or pop_back() function throws. -

      +In general, a default constructor is +not required. Certain container class member function signatures +specify the default constructorT() +as a default argument. T() shall be a well-defined expression (8.5) +if one of those signatures is called using the default argument +(8.3.6).

      -As far as I can tell, this is achieved by any implementation. If I made a -mistake and it is not possible to offer this guarantee, then -either state all the functions for which this is possible -(certainly at least operator+=, append, assign, and insert), -or add paragraphs to Effects clauses wherever appropriate. +Change 23.3.2.1 [deque.cons] para 5:

      - - - - -
      -

      851. simplified array construction

      -

      Section: 23.3.1 [array] Status: Open - Submitter: Benjamin Kosnik Opened: 2008-06-05 Last modified: 2009-07-25

      -

      View other active issues in [array].

      -

      View all other issues in [array].

      -

      View all issues with Open status.

      -

      Discussion:

      -

      -This is an issue that came up on the libstdc++ list, where a -discrepancy between "C" arrays and C++0x's std::array was pointed -out. -

      +
      +Effects: Constructs a deque with n +default constructedvalue-initialized +elements. +

      -In "C," this array usage is possible: +Change 23.3.2.2 [deque.capacity] para 1:

      -
      int ar[] = {1, 4, 6};
-
      +
      +Effects: If sz < size(), equivalent +to erase(begin() + sz, end());. If size() < sz, appends sz - +size() default +constructedvalue-initialized +elements to the sequence. +

      -But for C++, +Change 23.3.3.1 [forwardlist.cons] para 5:

      -
      std::array<int> a = { 1, 4, 6 }; // error
-
      +
      +Effects: Constructs a forward_list object with n default +constructedvalue-initialized +elements. +

      -Instead, the second parameter of the array template must be -explicit, like so: +Change 23.3.3.4 [forwardlist.modifiers] para 21:

      -
      std::array<int, 3> a = { 1, 4, 6 };
-
      +
      +Effects: [...] For the first signature +the inserted elements are default +constructedvalue-initialized, +and for the second signature they are copies of c. +

      -Doug Gregor proposes the following solution, that assumes -generalized initializer lists. +Change 23.3.4.1 [list.cons] para 5:

      -
      template<typename T, typename... Args>
-inline array<T, sizeof...(Args)> 
-make_array(Args&&... args) 
-{ return { std::forward<Args>(args)... };  }
-
      +
      +Effects: Constructs a list with n default +constructedvalue-initialized +elements. +

      -Then, the way to build an array from a list of unknown size is: +Change 23.3.4.2 [list.capacity] para 15:

      -
      auto a = make_array<T>(1, 4, 6);
-
      - -

      [ -San Francisco: -]

      +
      +Effects: If sz < size(), equivalent +to list<T>::iterator it = begin(); advance(it, sz); erase(it, +end());. If size() < sz, appends sz - size() default +constructedvalue-initialized +elements to the sequence. +
      +

      +Change 23.3.6.1 [vector.cons] para 3: +

      +Effects: Constructs a vector with n +default constructedvalue-initialized +elements. +
      +

      -Benjamin: Move to Ready? +Change 23.3.6.2 [vector.capacity] para 24:

      + +
      +Effects: If sz < size(), equivalent +to erase(begin() + sz, end());. If size() < sz, appends sz - +size() default +constructedvalue-initialized +elements to the sequence. +
      + + + + + + +
      +

      870. Do unordered containers not support function pointers for predicate/hasher?

      +

      Section: 23.2.5 [unord.req] Status: Open + Submitter: Daniel Krügler Opened: 2008-08-17 Last modified: 2009-10-20

      +

      View other active issues in [unord.req].

      +

      View all other issues in [unord.req].

      +

      View all issues with Open status.

      +

      Discussion:

      -Bjarne: I'm not convinced this is useful enough to add, so I'd like us -to have time to reflect on it. +Good ol' associative containers allow both function pointers and +function objects as feasible +comparators, as described in 23.2.4 [associative.reqmts]/2:

      + +
      +Each associative container is parameterized on Key and an ordering +relation Compare that +induces a strict weak ordering (25.3) on elements of Key. [..]. The +object of type Compare is +called the comparison object of a container. This comparison object +may be a pointer to +function or an object of a type with an appropriate function call operator.[..] +
      +

      -Alisdair: the constraints are wrong, they should be +The corresponding wording for unordered containers is not so clear, +but I read it to disallow +function pointers for the hasher and I miss a clear statement for the +equality predicate, see +23.2.5 [unord.req]/3+4+5:

      -
      template<ValueType T, ValueType... Args>
-requires Convertible<Args, T>...
-array<T, sizeof...(Args)> make_array(Args&&... args);
-
      + +

      -Alidair: this would be useful if we had a constexpr version. +Each unordered associative container is parameterized by Key, by a +function object Hash that +acts as a hash function for values of type Key, and by a binary +predicate Pred that induces an +equivalence relation on values of type Key.[..]

      -Bjarne: this is probably useful for arrays with a small number of -elements, but it's not clearly useful otherwise. +A hash function is a function object that takes a single argument of +type Key and returns a +value of type std::size_t.

      -Consensus is to move to Open. +Two values k1 and k2 of type Key are considered equal if the +container's equality function object +returns true when passed those values.[..]

      -

      [ -2009-06-07 Daniel adds: -]

      - - -

      -I suggest a fix and a simplification of the current proposal: Recent -prototyping by -Howard showed, that a fix is required because narrowing conversion -8.5.4 [dcl.init.list]/6 b.3 -would severely limit the possible distribution of argument types, e.g. -the expression -make_array<double>(1, 2.0) is ill-formed, because the narrowing -happens inside the -function body where no constant expressions exist anymore. Furthermore -given e.g. +and table 97 says in the column "assertion...post-condition" for the +expression X::hasher:

      -
      int f();
-double g();
-
      + +
      +Hash shall be a unary function object type such that the expression +hf(k) has type std::size_t. +
      +

      -we probably want to support +Note that 20.7 [function.objects]/1 defines as "Function objects are +objects with an operator() defined.[..]"

      -
      make_array<double>(f(), g());
-
      -

      -as well. To make this feasible, the currently suggested expansion +Does this restriction exist by design or is it an oversight? If an +oversight, I suggest that to apply +the following

      -
      { std::forward<Args>(args)... }
-
      +

      [ +2009-07-28 Reopened by Alisdair. No longer solved by concepts. +]

      -

      -needs to be replaced by -

      -
      { static_cast<T>(std::forward<Args>(args))... }
-
      +

      [ +2009-10 Santa Cruz: +]

      -

      -which is safe, because we already ensure convertibility via the -element-wise Convertible<Args, T> requirement. Some other fixes are -necessary: The ValueType requirement for the function parameters -is invalid, because all lvalue arguments will deduce to an lvalue-reference, -thereby no longer satisfying this requirement. -

      -

      -The suggested simplification is to provide a default-computed effective -type for the result array based on common_type and decay, in -unconstrained form: -

      +
      +Ask Daniel to provide proposed wording that: makes it explicit that +function pointers are function objects at the beginning of 20.7 [function.objects]; fixes the "requirements" for typedefs in +20.7.5 [refwrap] to instead state that the function objects +defined in that clause have these typedefs, but not that these typedefs +are requirements on function objects; remove the wording that explicitly +calls out that associative container comparators may be function +pointers. +
      -
      template<typename... Args>
-array<typename decay<typename common_type<Args...>::type>::type,
-sizeof...(Args)>
-make_array(Args&&... args);
-
      -

      -The approach used below is similar to that of make_pair and make_tuple -using a symbol C to represent the decayed common type [Note: Special -handling of reference_wrapper types is intentionally not provided, because -our target has so satisfy ValueType, thus under the revised proposal only -an all-reference_wrapper-arguments would be well-formed and an array of -reference_wrapper will be constructed]. I do currently not suggest to -add new concepts reflecting decay and common_type, but an implementor will -need something like this to succeed. Note that we use a similar fuzziness for -make_pair and make_tuple currently. This fuzziness is not related to -the currently -missing Constructible<Vi, Ti&&> requirement for those functions. The following -proposal fixes that miss for make_array. If the corresponding C type -deduction is -explicitly wanted for standardization, here the implementation -

      - -
      auto concept DC<typename... T> {
-  typename type = typename decay<typename common_type<T...>::type>::type;
-}
-
      +

      Proposed resolution:

      -where C is identical to DC<Args...>::type in the proposed resolution below. -

      -

      -I intentionally added no further type relation between type and the concept -template parameters, but instead added this requirement below to make -the specification as transparent as possible. As written this concept is -satisfied, if the corresponding associated type exists. +In 23.2.5 [unord.req]/3, just after the second sentence which is written as

      -

      Suggested Resolution:

      +
      +Additionally, unordered_map and unordered_multimap associate an +arbitrary mapped type T with the Key. +
      -
        -

      1. -Add to the array synopsis in 23.3 [sequences]: +add one further sentence:

        -
        
-template<ReferentType... Args>
-requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
-array<C, sizeof...(Args)>
-make_array(Args&&... args);
-
-
        -
        2. -
      2. +
        +Both Hash and Pred may be pointers to function or objects of a type +with an appropriate function call operator. +
        +

        -Append after 23.3.1.7 [array.tuple] Tuple interface to class template array -the following new section: +[Note1: Since the detailed requirements for Pred and Hash are given in +p.4 and p.5, it an alternative resolution +would be to insert a new paragraph just after p.5, which contains the +above proposed sentence]

        -

        -23.4.1.7 Array creation functions [array.creation] +[Note2: I do not propose a change of above quoted element in table 97, +because the mis-usage of the +notion of "function object" seems already present in the standard at +several places, even if it includes +function pointers, see e.g. 25 [algorithms]/7. The important point is +that in those places a statement is +given that the actually used symbol, like "Predicate" applies for +function pointers as well]

        -
        
-template<ReferentType... Args>
-requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
-array<C, sizeof...(Args)>
-make_array(Args&&... args);
-
        + +

        Rationale:

        +

        [ +San Francisco: +]

        +
        -

        -Let C be decay<common_type<Args...>::type>::type. -

        -

        -Returns: an array<C, sizeof...(Args)> initialized with -{ static_cast<C>(std::forward<Args>(args))... }. -

        -
        +This is fixed by +N2776.
        -
        3. -
      -
      -

      [ -2009-07 Frankfurt: -]

      -
      +
      +

      871. Iota's requirements on T are too strong

      +

      Section: 26.7.5 [numeric.iota] Status: Ready + Submitter: Daniel Krügler Opened: 2008-08-20 Last modified: 2009-10-22

      +

      View all issues with Ready status.

      +

      Discussion:

      -The proposed resolution uses concepts. +According to the recent WP +N2691, +26.7.5 [numeric.iota]/1, the requires clause +of std::iota says:

      + +
      +T shall meet the requirements of CopyConstructible and Assignable types, and +shall be convertible to ForwardIterator's value type.[..] +
      +

      -Daniel to rewrite the proposed resolution. +Neither CopyConstructible nor Assignable is needed, instead MoveConstructible +seems to be the correct choice. I guess the current wording resulted as an +artifact from comparing it with similar numerical algorithms like accumulate.

      +

      -Leave Open. +Note: If this function will be conceptualized, the here proposed +MoveConstructible +requirement can be removed, because this is an implied requirement of +function arguments, see +N2710/[temp.req.impl]/3, last bullet.

      -

      [ -2009-07-25 Daniel provides rewritten proposed resolution. +post San Francisco: ]

      +
      +Issue pulled by author prior to review. +
      +

      [ +2009-07-30 Daniel reopened: +]

      -

      Proposed resolution:

      -
        -
      1. -

        -Add to the array synopsis in 23.3 [sequences]: -

        +
        +with the absence of concepts, this issue (closed) is valid again and I +suggest to reopen it. +I also revised by proposed resolution based on N2723 wording: +
        -
        template<class... Args>
-  array<CT, sizeof...(Args)>
-  make_array(Args&&... args);
-
        -
        2. +

        [ +2009-10 Santa Cruz: +]

        -
      2. -

        -Append after 23.3.1.7 [array.tuple] "Tuple interface to class template array" the -following new section: -

        -

        -XX.X.X.X Array creation functions [array.creation] -

        +Change 'convertible' to 'assignable', Move To Ready. +
        -
        
-template<class... Args>
-array<CT, sizeof...(Args)>
-make_array(Args&&... args)
-
        -
        -

        -Let CT be decay<common_type<Args...>::type>::type. -

        + +

        Proposed resolution:

        -Returns: An array<CT, sizeof...(Args)> initialized with { -static_cast<CT>(std::forward<Args>(args))... }. +Change the first sentence of 26.7.5 [numeric.iota]/1:

        -

        -[Example: -

        -
        
-int i = 0; int& ri = i;
-make_array(42u, i, 2.78, ri);
-
        -

        -returns an array of type -

        -
        
-array<double, 4>
-
        - -

        -—end example] -

        -
        +
        +Requires: T shall meet the requirements of CopyConstructible and +Assignable types, and shall be +assignable to ForwardIterator's value type. [..]
        -
        3. - -
      @@ -11792,158 +9625,104 @@ array<double, 4>
      -

      854. default_delete converting constructor underspecified

      -

      Section: 20.8.9.1.1 [unique.ptr.dltr.dflt] Status: Review - Submitter: Howard Hinnant Opened: 2008-06-18 Last modified: 2009-07-26

      -

      View all issues with Review status.

      +

      872. move_iterator::operator[] has wrong return type

      +

      Section: 24.5.3.3.12 [move.iter.op.index] Status: Ready + Submitter: Doug Gregor Opened: 2008-08-21 Last modified: 2009-10-23

      +

      View all issues with Ready status.

      Discussion:

      -No relationship between U and T in the converting constructor for default_delete template. +move_iterator's operator[] is declared as:

      + +
      reference operator[](difference_type n) const;
+
      +

      -Requirements: U* is convertible to T* and has_virtual_destructor<T>; -the latter should also become a concept. -

      -

      -Rules out cross-casting. -

      -

      -The requirements for unique_ptr conversions should be the same as those on the deleter. +This has the same problem that reverse_iterator's operator[] used to +have: if the underlying iterator's operator[] returns a proxy, the +implicit conversion to value_type&& could end up referencing a temporary +that has already been destroyed. This is essentially the same issue that +we dealt with for reverse_iterator in DR 386.

      [ -Howard adds 2008-11-26: +2009-07-28 Reopened by Alisdair. No longer solved by concepts. ]

      -
      -

      -I believe we need to be careful to not outlaw the following use case, and -I believe the current proposed wording -(requires Convertible<U*, T*> && HasVirtualDestructor<T>) does so: -

      - -
      #include <memory>
-
-int main()
-{
-    std::unique_ptr<int> p1(new int(1));
-    std::unique_ptr<const int> p2(move(p1));
-    int i = *p2;
-//    *p2 = i;  // should not compile
-}
-
      - -

      -I've removed "&& HasVirtualDestructor<T>" from the -requires clause in the proposed wording. -

      - -
      -

      [ -Post Summit: +2009-08-15 Howard adds: ]

      -

      -Alisdair: This issue has to stay in review pending a paper constraining -unique_ptr. -

      -

      -Consensus: We agree with the resolution, but unique_ptr needs -to be constrained, too. -

      -

      -Recommend Keep in Review. -

      +I recommend closing this as a duplicate of 1051 which addresses +this issue for both move_iterator and reverse_iterator.

      [ -Batavia (2009-05): +2009-10 Santa Cruz: ]

      +
      -Keep in Review status for the reasons cited. +Move to Ready. Note that if 1051 is reopened, it may yield a +better resolution, but 1051 is currently marked NAD.
      -

      [ -2009-07 Frankfurt: -]

      -
      -

      -The proposed resolution uses concepts. Howard needs to rewrite the -proposed resolution. -

      +

      Proposed resolution:

      -Move back to Open. +In 24.5.3.1 [move.iterator] and 24.5.3.3.12 [move.iter.op.index], change the declaration of +move_iterator's operator[] to:

      -
      -

      [ -2009-07-26 Howard provided rewritten proposed wording and moved to Review. -]

      +
      reference unspecified operator[](difference_type n) const;
+
      -

      Proposed resolution:

      -

      -Add after 20.8.9.1.1 [unique.ptr.dltr.dflt], p1: -

      +

      Rationale:

      +

      [ +San Francisco: +]

      + -
      template <class U> default_delete(const default_delete<U>& other);
-
      -

      --1- Effects: ... -

      -

      -Remarks: This constructor shall participate in overload resolution -if and only if U* is implicitly convertible to T*. -

      -
      +NAD Editorial, see +N2777.
      - -
      -

      857. condition_variable::time_wait return bool error prone

      -

      Section: 30.5.1 [thread.condition.condvar] Status: Ready - Submitter: Beman Dawes Opened: 2008-06-13 Last modified: 2009-07-16

      -

      View other active issues in [thread.condition.condvar].

      -

      View all other issues in [thread.condition.condvar].

      -

      View all issues with Ready status.

      +

      885. pair assignment

      +

      Section: 20.3.4 [pairs] Status: Open + Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2009-07-17

      +

      View other active issues in [pairs].

      +

      View all other issues in [pairs].

      +

      View all issues with Open status.

      Discussion:

      -

      -The meaning of the bool returned by condition_variable::timed_wait is so -obscure that even the class' designer can't deduce it correctly. Several -people have independently stumbled on this issue. -

      -

      -It might be simpler to change the return type to a scoped enum: -

      -
      enum class timeout { not_reached, reached };
+
      20.2.3 pairs
+Missing assignemnt operator:
+template<class U , class V>
+  requires CopyAssignable<T1, U> && CopyAssignable<T2, V>
+    pair& operator=(pair<U , V> const & p );
 
      
 
 
      
-That's the same cost as returning a bool, but not subject to mistakes. Your example below would be:
+Well, that's interesting. This assignment operator isn't in the
+current working paper, either. Perhaps we deemed it acceptable to
+build a temporary of type pair from pair<U, V>, then move-assign
+from that temporary?
+
      
+
      
+It sounds more like an issue waiting to be opened, unless you want to plug
+it now.  As written we risk moving from lvalues.
 
      
 
-
      if (cv.wait_until(lk, time_limit) == timeout::reached )
-  throw time_out();
-
      
-
-
      [
-Beman to supply exact wording.
-]
      
-
-
 
      [
 San Francisco:
 ]
      
@@ -11951,376 +9730,349 @@ San Francisco:
 
 
      
 
      
-There is concern that the enumeration names are just as confusing, if
-not more so, as the bool. You might have awoken because of a signal or a
-spurious wakeup, for example.
-
      
-
      
-Group feels that this is a defect that needs fixing.
-
      
-
      
-Group prefers returning an enum over a void return.
+Would be NAD if better ctors fixed it.
 
      
 
      
-Howard to provide wording.
+Related to 811.
 
      
 
      
 
 
      [
-2009-06-14 Beman provided wording.
+post San Francisco:
 ]
      
 
 
+
      
+Possibly NAD Editorial, solved by
+N2770.
+
      
+
 
      [
-2009-07 Frankfurt:
+2009-05-25 Alisdair adds:
 ]
      
 
 
 
      
-Move to Ready.
+Issue 885 was something I reported while reviewing the library concepts
+documents ahead of San Francisco.  The missing operator was added as part of
+the paper adopted at that meeting
+(N2770)
+and I can confirm this operator is
+present in the current working paper.  I recommend NAD.
+
      
+
+
      [
+2009-07 Frankfurt
+]
      
+
+
+
      
+We agree with the intent, but we need to wait for the dust to settle on concepts.
 
      
 
 
 
 
      Proposed resolution:
      
 
      
-Change Condition variables 30.5 [thread.condition], Header
-condition_variable synopsis, as indicated:
 
      
 
-
      namespace std {
-  class condition_variable;
-  class condition_variable_any;
 
-  enum class cv_status { no_timeout, timeout };
-}
-
      
 
+
+
+
      
+
      887. issue with condition::wait_...
      
+
      Section: 30.5.1 [thread.condition.condvar] Status: Open
+ Submitter: Lawrence Crowl Opened: 2008-09-15  Last modified: 2009-10-26
      
+
      View other active issues in [thread.condition.condvar].
      
+
      View all other issues in [thread.condition.condvar].
      
+
      View all issues with Open status.
      
+
      Discussion:
      
 
      
-Change Class condition_variable 30.5.1 [thread.condition.condvar] as indicated:
+The Posix/C++ working group has identified an inconsistency between
+Posix and the C++ working draft in that Posix requires the clock to be
+identified at creation, whereas C++ permits identifying the clock at the
+call to wait.  The latter cannot be implemented with the former.
 
      
 
-
      class condition_variable { 
-public:
-  ...
-  template <class Clock, class Duration>
-    bool cv_status wait_until(unique_lock<mutex>& lock,
-                    const chrono::time_point<Clock, Duration>& abs_time);
-  template <class Clock, class Duration, class Predicate>
-    bool wait_until(unique_lock<mutex>& lock,
-                    const chrono::time_point<Clock, Duration>& abs_time,
-                    Predicate pred);
-
-  template <class Rep, class Period>
-    bool cv_status wait_for(unique_lock<mutex>& lock,
-                  const chrono::duration<Rep, Period>& rel_time);
-  template <class Rep, class Period, class Predicate>
-    bool wait_for(unique_lock<mutex>& lock,
-                  const chrono::duration<Rep, Period>& rel_time,
-                  Predicate pred);
-  ...
-};
+
      [
+San Francisco:
+]
      
 
-...
 
-template <class Clock, class Duration>
-  bool cv_status wait_until(unique_lock<mutex>& lock,
-                  const chrono::time_point<Clock, Duration>& abs_time);
-
      
 
      
 
      
--15- Precondition: lock is locked by the calling thread, and either
+Howard recommends NAD with the following explanation:
 
      
-
        
-
      • 
-no other thread is waiting on this condition_variable object or
-
        • 
-
      • 
-lock.mutex() returns the same value for each of the lock
-arguments supplied by all concurrently waiting threads (via wait,
-wait_for or wait_until.).
-
        • 
-
      
 
 
      
--16- Effects:
+The intent of the current wording is for the condtion_variable::wait_until
+be able to handle user-defined clocks as well as clocks the system knows about.
+This can be done by providing overloads for the known clocks, and another
+overload for unknown clocks which synchs to a known clock before waiting.
+For example:
 
      
 
-
        
-
      • 
-Atomically calls lock.unlock() and blocks on *this.
-
        • 
-
      • 
-When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
-
        • 
-
      • 
-The function will unblock when signaled by a call to notify_one(),
-a call to notify_all(), by 
-the current time exceeding abs_time if Clock::now() >= abs_time,
-or spuriously.
-
        • 
-
      • 
-If the function exits via an exception, lock.unlock() shall be called prior
-to exiting the function scope.
-
        • 
-
      
+
      template <class Duration>
+bool
+condition_variable::wait_until(unique_lock<mutex>& lock,
+                               const chrono::time_point<chrono::system_clock, Duration>& abs_time)
+{
+    using namespace chrono;
+    nanoseconds d = __round_up<nanoseconds>(abs_time.time_since_epoch());
+    __do_timed_wait(lock.mutex()->native_handle(), time_point<system_clock, nanoseconds>(d));
+    return system_clock::now() < abs_time;
+}
+
+template <class Clock, class Duration>
+bool
+condition_variable::wait_until(unique_lock<mutex>& lock,
+                               const chrono::time_point<Clock, Duration>& abs_time)
+{
+    using namespace chrono;
+    system_clock::time_point    s_entry = system_clock::now();
+    typename Clock::time_point  c_entry = Clock::now();
+    nanoseconds dn = __round_up<nanoseconds>(abs_time.time_since_epoch() -
+                                              c_entry.time_since_epoch());
+    __do_timed_wait(lock.mutex()->native_handle(), s_entry + dn);
+    return Clock::now() < abs_time;
+}
+
      
 
 
      
--17- Postcondition: lock is locked by the calling thread.
+In the above example, system_clock is the only clock which the underlying
+condition variable knows how to deal with.  One overload just passes that clock
+through.  The second overload (approximately) converts the unknown clock into
+a system_clock  time_point prior to passing it down to the native
+condition variable.
 
      
 
 
      
--18- Returns: Clock::now() < abs_time
-cv_status::timeout if the function unblocked because abs_time
-was reached, otherwise cv_status::no_timeout.
+On Posix systems vendors are free to add implementation defined constructors which
+take a clock.  That clock can be stored in the condition_variable, and converted
+to (or not as necessary) as shown above.
 
      
 
 
      
--19- Throws: std::system_error when the effects or postcondition
-cannot be achieved.
+If an implementation defined constructor takes a clock (for example), then part
+of the semantics for that implementation defined ctor might include that a
+wait_until using a clock other than the one constructed with results
+in an error (exceptional condition) instead of a conversion to the stored clock.
+Such a design is up to the vendor as once an implementation defined ctor is used,
+the vendor is free to specifiy the behavior of waits and/or notifies however
+he pleases (when the cv is constructed in an implementation defined manner).
 
      
+
      
+
+
      [
+Post Summit:
+]
      
 
+
+
      
 
      
--20- Error conditions:
+"POSIX people will review the proposed NAD resolution at their upcoming NY
+meeting.
 
      
 
-
        
-
      • 
-operation_not_permitted — if the thread does not own the lock.
-
        • 
-
      • 
-equivalent error condition from lock.lock() or lock.unlock().
-
        • 
-
      
-
      
-
-
      template <class Rep, class Period>
-  bool cv_status wait_for(unique_lock<mutex>& lock,
-                const chrono::duration<Rep, Period>& rel_time);
-
-
      
-
      
-
      
--21- Effects Returns:
-
      
-
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
-
      
 
      
--22- Returns: false if the call is returning because the time
-duration specified by rel_time has elapsed, 
-otherwise true.
+See the minutes at: http://wiki.dinkumware.com/twiki/bin/view/Posix/POSIX-CppBindingWorkingGroupNewYork2009.
 
      
+
      
 
 
      [
-This part of the wording may conflict with 859 in detail, but does
-not do so in spirit.  If both issues are accepted, there is a logical merge.
+2009-07 Frankfurt
 ]
      
 
+
+
      
+Move to NAD.
 
      
 
-
      template <class Clock, class Duration, class Predicate> 
-  bool wait_until(unique_lock<mutex>& lock, 
-                  const chrono::time_point<Clock, Duration>& abs_time, 
-                  Predicate pred);
-
      
+
      [
+2009-07-18 Detlef reopens the issue:
+]
      
+
 
 
      
 
      
--23- Effects:
+On Friday afternoon in Frankfurt is was decided that 887 is NAD.
+This decision was mainly based on a sample implementation presented
+by Howard that implemented one clock on top of another.
+Unfortunately this implementation doesn't work for the probably most
+important case where a system has a monotonic clock and a real-time
+clock (or "wall time" clock):
 
      
-
      while (!pred()) 
-  if (!wait_until(lock, abs_time) == cv_status::timeout) 
-    return pred(); 
-return true;
-
      
-
 
      
--24- Returns: pred().
+If the underlying "system_clock" is a monotonic clock, and
+the program waits on the real-time clock, and the real-time clock
+is set forward, the wait will unblock too late.
 
      
 
 
      
--25- [Note:
-The returned value indicates whether the predicate evaluates to
-true regardless of whether the timeout was triggered.
-— end note].
+If the underlying "system_clock" is a real-time clock, and the
+program waits on the monotonic clock, and the real-time clock
+is set back, the wait again will unblock too late.
 
      
-
      
-
      
 
 
      
-Change Class condition_variable_any 30.5.2 [thread.condition.condvarany] as indicated:
+Sorry that I didn't remember this on Friday, but it was Friday
+afternoon after a busy week...
 
      
 
-
      class condition_variable_any {
-public:
-  ...
-  template <class Lock, class Clock, class Duration>
-    bool cv_status wait_until(Lock& lock,
-                    const chrono::time_point<Clock, Duration>& abs_time);
-  template <class Lock, class Clock, class Duration, class Predicate>
-    bool wait_until(Lock& lock,
-                    const chrono::time_point<Clock, Duration>& abs_time,
-                    Predicate pred);
-
-  template <class Lock, class Rep, class Period>
-    bool cv_status wait_for(Lock& lock,
-                  const chrono::duration<Rep, Period>& rel_time);
-  template <class Lock, class Rep, class Period, class Predicate>
-    bool wait_for(Lock& lock,
-                  const chrono::duration<Rep, Period>& rel_time,
-                  Predicate pred);
-  ...
-};
+
      
+So as the decision was made on a wrong asumption, I propose to re-open
+the issue.
+
      
+
      
 
-...
+
      [
+2009-07-26 Howard adds:
+]
      
 
-template <class Lock, class Clock, class Duration>
-  bool cv_status wait_until(Lock& lock,
-                  const chrono::time_point<Clock, Duration>& abs_time);
-
      -

      --13- Effects: +Detlef correctly argues that condition_variable::wait_until could +return "too late" in the context of clocks being adjusted during the wait. I agree +with his logic. But I disagree that this makes this interface unimplementable +on POSIX.

      -
        -
      • -Atomically calls lock.unlock() and blocks on *this. -
        • -
      • -When unblocked, calls lock.lock() (possibly blocking on the lock) and returns. -
        • -
      • -The function will unblock when signaled by a call to notify_one(), -a call to notify_all(), by -the current time exceeding abs_time if Clock::now() >= abs_time, -or spuriously. -
        • -
      • -If the function exits via an exception, lock.unlock() shall be called prior -to exiting the function scope. -
        • -
      -

      --14- Postcondition: lock is locked by the calling thread. +The POSIX spec also does not guarantee that pthread_cond_timedwait does +not return "too late" when clocks are readjusted during the wait. Indeed, the +POSIX specification lacks any requirements at all concerning how soon +pthread_cond_timedwait returns after a time out. This is evidently a +QOI issue by the POSIX standard. Here is a quote of the most relevant normative +text concerning pthread_cond_timedwait found +here.

      +
      +The pthread_cond_timedwait() function shall be equivalent to +pthread_cond_wait(), except that an error is returned if the absolute +time specified by abstime passes (that is, system time equals or exceeds +abstime) before the condition cond is signaled or broadcasted, or if the +absolute time specified by abstime has already been passed at the time +of the call. +
      +

      --15- Returns: Clock::now() < abs_time -cv_status::timeout if the function unblocked because abs_time -was reached, otherwise cv_status::no_timeout. +I.e. the POSIX specification speaks of the error code returned in case of a time +out, but not on the timeliness of that return.

      --16- Throws: std::system_error when the effects or postcondition -cannot be achieved. +Might this simply be an oversight, or minor defect in the POSIX specification?

      --17- Error conditions: +I do not believe so. This same section goes on to say in non-normative +text:

      -
        -
      • -equivalent error condition from lock.lock() or lock.unlock(). -
        • -
      +
      +For cases when the system clock is advanced discontinuously by an +operator, it is expected that implementations process any timed wait +expiring at an intervening time as if that time had actually occurred.
      -
      template <class Lock, class Rep, class Period>
-  bool cv_status wait_for(Lock& lock,
-                const chrono::duration<Rep, Period>& rel_time);
-
-
      - -

      --18- Effects Returns: +Here is non-normative wording encouraging the implementation to ignore an advancing +underlying clock and subsequently causing an early (spurious) return. There is +no wording at all which addresses Detlef's example of a "late return". With +pthread_cond_timedwait this would be caused by setting the system clock +backwards. It seems reasonable to assume, based on the wording that is already +in the POSIX spec, that again, the discontinuously changed clock would be ignored +by pthread_cond_timedwait.

      -
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
-

      --19- Returns: false if the call is returning because the time -duration specified by rel_time has elapsed, -otherwise true. +A noteworthy difference between pthread_cond_timedwait and +condition_variable::wait_until is that the POSIX spec appears to +say that ETIMEDOUT should be returned if pthread_cond_timedwait +returns because of timeout signal, whether or not the system clock was discontinuously +advanced during the wait. In contrast condition_variable::wait_until +always returns:

      -

      [ -This part of the wording may conflict with 859 in detail, but does -not do so in spirit. If both issues are accepted, there is a logical merge. -]

      - - -
      +
      Clock::now() < abs_time
+
      -
      template <class Lock, class Clock, class Duration, class Predicate> 
-  bool wait_until(Lock& lock, 
-                  const chrono::time_point<Clock, Duration>& rel_time abs_time, 
-                  Predicate pred);
-
      +

      +That is, the C++ spec requires that the clock be rechecked (detecting discontinuous +adjustments during the wait) at the time of return. condition_variable::wait_until +may indeed return early or late. But regardless it will return a value +reflecting timeout status at the time of return (even if clocks have been adjusted). +Of course the clock may be adjusted after the return value is computed but before the client has +a chance to read the result of the return. Thus there are no iron-clad guarantees +here. +

      -

      --20- Effects: +condition_variable::wait_until (and pthread_cond_timedwait) +is little more than a convenience function for making sure +condition_variable::wait doesn't hang for an unreasonable amount of +time (where the client gets to define "unreasonable"). I do not think it +is in anyone's interest to try to make it into anything more than that.

      -
      while (!pred()) 
-  if (!wait_until(lock, abs_time) == cv_status::timeout) 
-    return pred(); 
-return true;
-

      --21- Returns: pred(). +I maintain that this is a useful and flexible specification in the spirit of +C++, and is implementable on POSIX. The implementation technique described above +is a reasonable approach. There may also be higher quality approaches. This +specification, like the POSIX specification, gives a wide latitude for QOI.

      --22- [Note: -The returned value indicates whether the predicate evaluates to -true regardless of whether the timeout was triggered. -— end note]. +I continue to recommend NAD, but would not object to a clarifying note regarding +the behavior of condition_variable::wait_until. At the moment, I do +not have good wording for such a note, but welcome suggestions.

      -
      +

      [ +2009-09-30: See N2969. +]

      +

      [ +2009-10 Santa Cruz: +]

      +
      +The LWG is in favor of Detlef to supply revision which adopts Option 2 from +N2969 +but is modified by saying that system_clock must be available for wait_until. +
      -
      -

      859. Monotonic Clock is Conditionally Supported?

      -

      Section: 30.5 [thread.condition] Status: Ready - Submitter: Pete Becker Opened: 2008-06-23 Last modified: 2009-07-21

      -

      View all issues with Ready status.

      -

      Discussion:

      -

      Related to 958, 959.

      +

      Proposed resolution:

      -N2661 -says that there is a class named monotonic_clock. It also says that this -name may be a synonym for system_clock, and that it's conditionally -supported. So the actual requirement is that it can be monotonic or not, -and you can tell by looking at is_monotonic, or it might not exist at -all (since it's conditionally supported). Okay, maybe too much -flexibility, but so be it. -

      -

      -A problem comes up in the threading specification, where several -variants of wait_for explicitly use monotonic_clock::now(). What is the -meaning of an effects clause that says

      -
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
-
      + + + + +
      +

      889. thread::id comparisons

      +

      Section: 30.3.1.1 [thread.thread.id] Status: Ready + Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-10-22

      +

      View all other issues in [thread.thread.id].

      +

      View all issues with Ready status.

      +

      Discussion:

      + +

      Addresses UK 324

      -when monotonic_clock is not required to exist? +The thread::id type supports the full set of comparison operators. This +is substantially more than is required for the associative containers that +justified them. Please place an issue against the threads library.

      [ @@ -12330,1217 +10082,828 @@ San Francisco:

      -Nick: maybe instead of saying that chrono::monotonic_clock is -conditionally supported, we could say that it's always there, but not -necessarily supported.. -

      -

      -Beman: I'd prefer a typedef that identifies the best clock to use for -wait_for locks. -

      -

      -Tom: combine the two concepts; create a duration clock type, but keep -the is_monotonic test. -

      -

      -Howard: if we create a duration_clock type, is it a typedef or an -entirely true type? -

      -

      -There was broad preference for a typedef. +Would depend on proposed extension to POSIX, or non-standard extension. +What about hash? POSIX discussing op. POSIX not known to be considering +support needed for hash, op.

      -Move to Open. Howard to provide wording to add a typedef for -duration_clock and to replace all uses of monotonic_clock in function -calls and signatures with duration_clock. +Group expresses support for putting ids in both unordered and ordered containers.

      [ -Howard notes post-San Francisco: +post San Francisco: ]

      -After further thought I do not believe that creating a duration_clock typedef -is the best way to proceed. An implementation may not need to use a -time_point to implement the wait_for functions. +Howard: It turns out the current working paper +N2723 +already has hash<thread::id> +(20.7 [function.objects], 20.7.16 [unord.hash]). We simply +overlooked it in the meeting. It is a good thing we voted in favor of it +(again). :-)

      -

      -For example, on POSIX systems sleep_for can be implemented in terms of -nanosleep which takes only a duration in terms of nanoseconds. The current -working paper does not describe sleep_for in terms of sleep_until. -And paragraph 2 of 30.2.4 [thread.req.timing] has the words strongly encouraging -implementations to use monotonic clocks for sleep_for: +Recommend NAD.

      -
      -2 The member functions whose names end in _for take an argument that -specifies a relative time. Implementations should use a monotonic clock to -measure time for these functions.
      -

      -I believe the approach taken in describing the effects of sleep_for -and try_lock_for is also appropriate for wait_for. I.e. these -are not described in terms of their _until variants. -

      +

      [ +Post Summit: +]

      + +
      +Recommend to close as NAD. For POSIX, see if we need to add a function to +convert pthread_t to integer.

      [ -2009-07 Frankfurt: +Post Summit, Alisdair adds: ]

      -Beman will send some suggested wording changes to Howard. +The recommendation for LWG-889/UK-324 is NAD, already specified.

      -Move to Ready. +It is not clear to me that the specification is complete. +

      +

      +In particular, the synopsis of <functional> in 20.7 [function.objects] does not mention hash< thread::id +> nor hash< error_code >, although their +existence is implied by 20.7.16 [unord.hash], p1. +

      +

      +I am fairly uncomfortable putting the declaration for the +thread_id specialization into <functional> as +id is a nested class inside std::thread, so it implies +that <functional> would require the definition of the +thread class template in order to forward declared +thread::id and form this specialization. +

      +

      +It seems better to me that the dependency goes the other way around +(<thread> will more typically make use of +<functional> than vice-versa) and the +hash<thread::id> specialization be declared in the +<thread> header. +

      +

      +I think hash<error_code> could go into either +<system_error> or <functional> and have no +immediate preference either way. However, it should clearly appear in +the synopsis of one of these two. +

      +

      +Recommend moving 889 back to open, and tying in a reference to UK-324.

      [ -2009-07-21 Beman added the requested wording changes to 962. +Batavia (2009-05): ]

      +
      +Howard observes that thread::id need not be a nested class; +it could be a typedef for a more visible type. +
      - - -

      Proposed resolution:

      -

      -Change 30.5.1 [thread.condition.condvar], p21-22: -

      +

      [ +2009-05-24 Alisdair adds: +]

      -
      template <class Rep, class Period> 
-  bool wait_for(unique_lock<mutex>& lock, 
-                const chrono::duration<Rep, Period>& rel_time);
-
      -
      -

      -Precondition: lock is locked by the calling thread, and either -

      -
        -
      • no other thread is waiting on this condition_variable object or
        • -
      • lock.mutex() returns the same value for each of the lock -arguments supplied by all concurrently waiting threads (via wait, -wait_for or wait_until).
        • -
      -

      -21 Effects: -

      -
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
-
      -
        -
      • -Atomically calls lock.unlock() and blocks on *this. -
        • - -
      • -When unblocked, calls lock.lock() (possibly blocking on the lock) and returns. -
        • +I do not believe this is correct. thread::id is explicitly documents as a +nested class, rather than as an unspecified typedef analogous to an +iterator. If the intent is that this is not implemented as a nested class +(under the as-if freedoms) then this is a novel form of standardese. +
      -
    • -The function will unblock when signaled by a call to notify_one(), a call -to notify_all(), by -the elapsed time rel_time passing (30.2.4 [thread.req.timing]), -or spuriously. -
      • +

      [ +2009-07 Frankfurt +]

      -
    • -If the function exits via an exception, lock.unlock() shall be called -prior to exiting the function scope. -
      • -
    -

    -Postcondition: lock is locked by the calling thread. -

    +
    +Decided we want to move hash specialization for thread_id to the thread +header. Alisdair to provide wording. +
    +

    [ +2009-07-28 Alisdair provided wording, moved to Review. +]

    -

    -22 Returns: false if the call is returning because the time -duration specified by rel_time has elapsed, otherwise true. -

    [ -This part of the wording may conflict with 857 in detail, but does -not do so in spirit. If both issues are accepted, there is a logical merge. +2009-10 Santa Cruz: ]

    -

    -Throws: std::system_error when the effects or postcondition cannot be achieved. -

    +
    +Add a strike for hash<thread::id>. Move to Ready +
    -

    -Error conditions: -

    -
      -
    • -operation_not_permitted -- if the thread does not own the lock. -
      • -
    • -equivalent error condition from lock.lock() or lock.unlock(). -
      • -
    - - +

    Proposed resolution:

    -Change 30.5.1 [thread.condition.condvar], p26-p29: +Remove the following prototype from the synopsis in +20.7 [function.objects]:

    -
    -
    template <class Rep, class Period, class Predicate> 
-  bool wait_for(unique_lock<mutex>& lock, 
-                const chrono::duration<Rep, Period>& rel_time, 
-                Predicate pred);
-
    -
    -

    -Precondition: lock is locked by the calling thread, and either -

    -
      -
    • no other thread is waiting on this condition_variable object or
      • -
    • lock.mutex() returns the same value for each of the lock -arguments supplied by all concurrently waiting threads (via wait, -wait_for or wait_until).
      • -
    -

    -26 Effects: -

    -
    wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))
-
    -
      -
    • -Executes a loop: Within the loop the function first evaluates pred() -and exits the loop if the result of pred() is true. -
      • -
    • -Atomically calls lock.unlock() -and blocks on *this. -
      • -
    • -When unblocked, calls lock.lock() (possibly blocking on the lock). -
      • -
    • -The function will unblock when signaled by a call to notify_one(), a -call to notify_all(), by the elapsed time rel_time passing (30.1.4 -[thread.req.timing]), or spuriously. -
      • -
    • -If the function exits via an exception, lock.unlock() shall be called -prior to exiting the function scope. -
      • -
    • -The loop terminates when pred() returns true or when the time -duration specified by rel_time has elapsed. -
      • -
    -
    +
    
+template <> struct hash<std::thread::id>;
+

    -27 [Note: There is no blocking if pred() is initially true, -even if the timeout has already expired. -- end note] +Add to 30.3 [thread.threads], p1 Header <thread> synopsis:

    -

    -Postcondition: lock is locked by the calling thread. -

    +
    template <class T> struct hash;
+template <> struct hash<thread::id>;
+

    -28 Returns: pred() +Add template specialization below class definition in 30.3.1.1 [thread.thread.id]

    +
    template <>
+struct hash<thread::id> : public unary_function<thread::id, size_t> {
+   size_t operator()(thread::id val) const;
+};
+
    +

    -29 [Note: The returned value indicates whether the predicate evaluates to -true regardless of whether the timeout was triggered. -- end note] +Extend note in p2 30.3.1.1 [thread.thread.id] with second sentence:

    -

    -Throws: std::system_error when the effects or postcondition cannot be achieved. -

    - -

    -Error conditions: -

    - -
      -
    • -operation_not_permitted -- if the thread does not own the lock. -
      • -
    • -equivalent error condition from lock.lock() or lock.unlock(). -
      • -
    - -
    +
    +[Note: Relational operators allow thread::id objects to be used +as keys in associative containers. +hash template specialization allow thread::id objects to be used as keys +in unordered containers. +— end note]

    -Change 30.5.2 [thread.condition.condvarany], p18-19: +Add new paragraph to end of 30.3.1.1 [thread.thread.id]

    -
    -
    template <class Lock, class Rep, class Period> 
-  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
+
    template <> struct hash<thread::id>;
 
    
-
    
-
    
-18 Effects:
-
    
-
    wait_until(lock, chrono::monotonic_clock::now() + rel_time)
-
    
-
-
      
-
    • 
-Atomically calls lock.unlock() and blocks on *this.
-
      • 
+
      
+An explicit specializations of the class template hash (20.7.16 [unord.hash])
+shall be provided for the values of type thread::id
+suitable for use as keys in unordered associative containers (23.5 [unord]).
+
      
+
    
 
-
  • 
-When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
-
    • 
 
-
  • 
-The function will unblock when signaled by a call to notify_one(), a call to
-notify_all(), by
-the elapsed time rel_time passing (30.2.4 [thread.req.timing]),
-or spuriously.
-
    • 
 
-
  • 
-If the function exits via an exception, lock.unlock() shall be called
-prior to exiting the function scope.
-
    • 
-
 
-
    
-Postcondition: lock is locked by the calling thread.
-
    
 
+
    
+
    891. std::thread, std::call_once issue
    
+
    Section: 30.3.1.2 [thread.thread.constr], 30.4.5.2 [thread.once.callonce] Status: Open
+ Submitter: Peter Dimov Opened: 2008-09-15  Last modified: 2009-10-24
    
+
    View other active issues in [thread.thread.constr].
    
+
    View all other issues in [thread.thread.constr].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
+
    
+I notice that the vararg overloads of std::thread and std::call_once
+(N2723 30.3.1.2 [thread.thread.constr] and 30.4.5.2 [thread.once.callonce]) are no longer specified in terms of
+std::bind; instead, some of the std::bind wording has been inlined into
+the specification.
+
    
+
    
+There are two problems with this.
+
    
 
    
-19 Returns: false if the call is returning because the time duration
-specified by rel_time has elapsed, otherwise true.
+First, the specification (and implementation) in terms of std::bind allows, for example:
 
    
 
-
    
-Throws: std::system_error when the returned value, effects,
-or postcondition cannot be achieved.
-
    
+
    std::thread th( f, 1, std::bind( g ) );
+
    
 
-
    
-Error conditions:
-
    
+
    
+which executes f( 1, g() ) in a thread. This can be useful. The
+"inlined" formulation changes it to execute f( 1, bind(g) ) in a thread.
+
    
+
    
+Second, assuming that we don't want the above, the specification has copied the wording
+
    
 
-
      
-
    • 
-equivalent error condition from lock.lock() or lock.unlock().
-
      • 
-
    
-
    
+
    
+INVOKE(func, w1, w2, ..., wN) (20.6.2) shall be a valid
+expression for some values w1, w2, ..., wN
 
    
 
 
    
-Change 30.5.2 [thread.condition.condvarany], p23-p26:
+but this is not needed since we know that our argument list is args; it should simply be
 
    
 
 
    
-
    template <class Lock, class Rep, class Period, class Predicate> 
-  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
-
    
-
    
-
    
-Precondition: lock is locked by the calling thread, and either
-
    
-
      
-
    • no other thread is waiting on this condition_variable object or
      • 
-
    • lock.mutex() returns the same value for each of the lock
-arguments supplied by all concurrently waiting threads (via wait,
-wait_for or wait_until).
      • 
-
    
-
    
-23 Effects:
-
    
-
    wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))
-
    
-
      
-
    • 
-Executes a loop:  Within the loop the function first evaluates pred()
-and exits the loop if the result of pred() is true.
-
      • 
-
    • 
-Atomically calls lock.unlock()
-and blocks on *this.
-
      • 
-
    • 
-When unblocked, calls lock.lock() (possibly blocking on the lock).
-
      • 
-
    • 
-The function will unblock when signaled by a call to notify_one(), a
-call to notify_all(), by the elapsed time rel_time passing (30.1.4
-[thread.req.timing]), or spuriously.
-
      • 
-
    • 
-If the function exits via an exception, lock.unlock() shall be called
-prior to exiting the function scope.
-
      • 
-
    • 
-The loop terminates when pred() returns true or when the time
-duration specified by rel_time has elapsed.
-
      • 
-
    
+INVOKE(func, args...) (20.6.2) shall be a valid expression
 
    
 
-
    
-24 [Note: There is no blocking if pred() is initially true,
-even if the timeout has already expired. -- end note]
-
    
+
    [
+Summit:
+]
    
 
-
    
-Postcondition: lock is locked by the calling thread.
-
    
 
-
    
-25 Returns: pred()
-
    
+
    
+Move to open.
+
    
 
-
    
-26 [Note: The returned value indicates whether the predicate evaluates to
-true regardless of whether the timeout was triggered. -- end note]
-
    
+
    [
+Post Summit Anthony provided proposed wording.
+]
    
 
-
    
-Throws: std::system_error when the effects or postcondition cannot be achieved.
-
    
 
-
    
-Error conditions:
-
    
+
    [
+2009-07 Frankfurt
+]
    
 
-
      
-
    • 
-operation_not_permitted -- if the thread does not own the lock.
-
      • 
-
    • 
-equivalent error condition from lock.lock() or lock.unlock().
-
      • 
-
    
 
+
    
+Leave Open. Await decision for thread variadic constructor.
 
    
-
    
-
 
+
    [
+2009-10 Santa Cruz:
+]
    
 
 
+
    
+See proposed wording for 929 for this, for the formulation
+on how to solve this.  929 modifies the thread constructor to
+have "pass by value" behavior with pass by reference efficiency through the use
+of the decay trait.  This same formula would be useful for call_once.
+
    
 
 
 
-
    
-
    860. Floating-Point State
    
-
    Section: 26 [numerics] Status: Open
- Submitter: Lawrence Crowl Opened: 2008-06-23  Last modified: 2009-03-09
    
-
    View all other issues in [numerics].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    Proposed resolution:
    
 
    
-There are a number of functions that affect the floating point state.
-These function need to be thread-safe, but I'm unsure of the right
-approach in the standard, as we inherit them from C.
+Change paragraph 4 of 30.3.1.2 [thread.thread.constr] to:
 
    
 
-
    [
-San Francisco:
-]
    
-
-
 
    
-
    
-Nick: I think we already say that these functions do not introduce data
-races; see 17.6.5.6/20
-
    
-
    
-Pete: there's more to it than not introducing data races; are these
-states maintained per thread?
-
    
-
    
-Howard: 21.5/14 says that strtok and strerror are not required to avoid
-data races, and 20.9/2 says the same about asctime, gmtime, ctime, and
-gmtime.
-
    
-
    
-Nick: POSIX has a list of not-safe functions. All other functions are
-implicitly thread safe.
-
    
-
    
-Lawrence is to form a group between meetings to attack this issue. Nick
-and Tom volunteered to work with Lawrence.
-
    
-
    
-Move to Open.
-
    
-
    
-
-
    [
-Post Summit:
-]
    
-
-
+
    template <class F> explicit thread(F f);
+template <class F, class ...Args> thread(F&& f, Args&&... args);
+
    
 
    
-
    
-Hans: Sane oses seem ok. Sensible thing is implementable and makes sense.
-
    
-
    
-Nick: Default wording seems to cover this? Hole in POSIX, these
-functions need to be added to list of thread-unsafe functions.
-
    
-
    
-Lawrence: Not sufficient, not "thread-safe" per our definition, but
-think of state as a thread-local variable. Need something like "these
-functions only affect state in the current thread."
-
    
-
    
-Hans: Suggest the following wording: "The floating point environment is
-maintained per-thread."
-
    
-
    
-Walter: Any other examples of state being thread safe that are not
-already covered elsewhere?
-
    
-
    
-Have thread unsafe functions paper which needs to be updated. Should
-just fold in 26.3 [cfenv] functions.
-
    
-
    
-Recommend Open. Lawrence instead suggests leaving it open until we have
-suitable wording that may or may not include the thread local
-commentary.
-
    
+-4- Requires: F and each Ti in Args
+shall be CopyConstructible if an lvalue and otherwise
+MoveConstructible. INVOKE(f, w1, w2, ..., wN args...)
+(20.6.2) shall be a valid expression for some values w1, w2, ...,
+wN, where N == sizeof...(Args).
+
    
 
    
 
-
-
    Proposed resolution:
    
 
    
+Change paragraph 1 of 30.4.5.2 [thread.once.callonce] to:
 
    
 
+
    template<class Callable, class ...Args> 
+  void call_once(once_flag& flag, Callable func, Args&&... args);
+
    
+
    
+-1- Requires: The template parameters Callable> and each
+Ti in Args shall be CopyConstructible if an
+lvalue and otherwise MoveConstructible. INVOKE(func,
+w1, w2, ..., wN args...) (20.6.2) shall be a
+valid expression for some values w1, w2, ..., wN, where
+N == sizeof...(Args).
+
    
+
    
+
 
 
 
 
 
    
-
    861. Incomplete specification of EqualityComparable for std::forward_list
    
-
    Section: 23.2 [container.requirements] Status: Open
- Submitter: Daniel Krügler Opened: 2008-06-24  Last modified: 2009-07-26
    
-
    View other active issues in [container.requirements].
    
-
    View all other issues in [container.requirements].
    
-
    View all issues with Open status.
    
+
    893. std::mutex issue
    
+
    Section: 30.4.1.1 [thread.mutex.class] Status: Ready
+ Submitter: Peter Dimov Opened: 2008-09-15  Last modified: 2009-10-22
    
+
    View all other issues in [thread.mutex.class].
    
+
    View all issues with Ready status.
    
+
    Duplicate of: 905
    
 
    Discussion:
    
 
    
-Table 89, Container requirements, defines operator== in terms of the container
-member function size() and the algorithm std::equal:
-
    
-
-
    
-== is an equivalence relation. a.size() == b.size() &&
-equal(a.begin(), a.end(), b.begin()
-
    
-
-
    
-The new container forward_list does not provide a size member function
-by design but does provide operator== and operator!= without specifying it's semantic.
-
    
-
    
-Other parts of the (sequence) container requirements do also depend on
-size(), e.g. empty()
-or clear(), but this issue explicitly attempts to solve the missing
-EqualityComparable specification,
-because of the special design choices of forward_list.
+30.4.1.1 [thread.mutex.class]/27 (in
+N2723)
+says that the behavior is undefined if:
 
    
+
      
+
    • a thread that owns a mutex object calls lock() or
+try_lock() on that object
      • 
+
    
 
    
-I propose to apply one of the following resolutions, which are described as:
+I don't believe that this is right. Calling lock() or try_lock() on a
+locked mutex is well defined in the general case. try_lock() is required
+to fail and return false. lock() is required to either throw an
+exception (and is allowed to do so if it detects deadlock) or to block
+until the mutex is free. These general requirements apply regardless of
+the current owner of the mutex; they should apply even if it's owned by
+the current thread.
 
    
-
-
      
-
    1. 
-Provide a definition, which is optimal for this special container without
-previous size test. This choice prevents two O(N) calls of std::distance()
-with the corresponding container ranges and instead uses a special
-equals implementation which takes two container ranges instead of 1 1/2.
-
      2. 
-
    2. 
-The simple fix where the usual test is adapted such that size() is replaced
-by distance with corresponding performance disadvantages.
-
      3. 
-
    
 
    
-Both proposal choices are discussed, the preferred choice of the author is
-to apply (A).
+Making double lock() undefined behavior probably can be justified (even
+though I'd still disagree with the justification), but try_lock() on a
+locked mutex must fail.
 
    
 
 
    [
-San Francisco:
+Summit:
 ]
    
 
-
 
    
 
    
-There's an Option C: change the requirements table to use distance().
-
    
-
    
-LWG found Option C acceptable.
-
    
-
    
-Martin will draft the wording for Option C.
+Move to open. Proposed resolution:
 
    
+
      
+
    • 
+In 30.4.1 [thread.mutex.requirements] paragraph 12, change the error
+condition for resource_deadlock_would_occur to: "if the implementation
+detects that a deadlock would occur"
+
      • 
+
    • 
+Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2 "a thread that owns a mutex object
+calls lock() or try_lock() on that object, or"
+
      • 
+
    
 
    
 
 
    [
-post San Francisco:
+2009-07 Frankfurt
 ]
    
 
 
 
    
-Martin provided wording for Option C.
+Move to Review. Alisdair to provide note.
 
    
 
 
    [
-2009-07 Frankfurt
+2009-07-31 Alisdair provided note.
 ]
    
 
 
-
    
-
    
-Other operational semantics (see, for example, Tables 82 and 83) are
-written in terms of a container's size() member. Daniel to update
-proposed resolution C.
-
    
 
    [
-Howard: Commented out options A and B.
+2009-10 Santa Cruz:
 ]
    
 
-
    
-
-
    [
-2009-07-26 Daniel updated proposed resolution C.
-]
    
 
+
    
+Moved to Ready.
+
    
 
 
 
 
    Proposed resolution:
    
-
-
 
    
-Option (C):
+In 30.4.1 [thread.mutex.requirements] paragraph 12 change:
 
    
-
    
-
-
    [
-The changes are relative to
-N2914
-but concept-free.
-]
    
-
 
-
      
+
      
+
        
+
      • ...
        • 
 
      • 
-
        
-In 23.2.1 [container.requirements.general] change Table 80 -- Container requirements as indicated:
-
        
+resource_deadlock_would_occur -- if the current thread already owns the mutex and is able 
+to detect it implementation detects that a deadlock would occur.
+
        • 
+
      • ...
        • 
+
      
+
      
 
-
        
-
      1. 
 
        
-Change the text in the Assertion/note column in the row for "X u;"
-as follows:
+Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2:
 
        
-
 
        
-post: u.size() == 0empty() == true
-
        
+
        
+-3- The behavior of a program is undefined if:
+
        
+
          
+
        • ...
          • 
+
        • 
+a thread that owns a mutex object calls lock() or try_lock() on that object, or
 
          • 
+
        • ...
          • 
+
        
+
    
 
-
  • 
 
    
-Change the text in the Assertion/note column in the row for "X();"
-as follows:
+Add the following note after p3 30.4.1.1 [thread.mutex.class]
 
    
 
 
    
-X().size() == 0empty() == true
+[Note: a program may deadlock if the thread that owns a mutex
+object calls lock() or try_lock() on that object. If the program can
+detect the deadlock, a resource_deadlock_would_occur error condition may
+be observed. — end note]
 
    
-
    • 
 
-
  • 
+
+
+
+
+
+
    
+
    896. Library thread safety issue
    
+
    Section: 20.8.15.2 [util.smartptr.shared] Status: Open
+ Submitter: Hans Boehm Opened: 2008-09-16  Last modified: 2009-10-25
    
+
    View all other issues in [util.smartptr.shared].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-Change the text in the Operational Semantics column in the row for
-"a == b" as follows:
+It is unclear whether shared_ptr is thread-safe in the sense that
+multiple threads may simultaneously copy a shared_ptr.  However this
+is a critical piece of information for the client, and it has significant
+impact on usability for many applications.  (Detlef Vollman thinks it
+is currently clear that it is not thread-safe.  Hans Boehm thinks
+it currently requires thread safety, since the use_count is not an
+explicit field, and constructors and assignment take a const reference
+to an existing shared_ptr.)
 
    
-
    
-== is an equivalence relation.
-a.size()distance(a.begin(), a.end()) ==
-   b.size()distance(b.begin(), b.end()) &&
-equal(a.begin(), a.end(), b.begin())
-
    
-
    • 
 
-
  • 
 
    
-Change the text in the Operational Semantics column in the row for
-"a.size()" as follows:
+Pro thread-safety:
 
    
-
-
    
-a.end() - a.begin()distance(a.begin(), a.end())
-
    
-
    • 
-
-
  • 
 
    
-Change the text in the Operational Semantics column in the row for
-"a.max_size()" as follows:
+Many multi-threaded usages are impossible.  A thread-safe version can
+be used to destroy an object when the last thread drops it, something
+that is often required, and for which we have no other easy mechanism.
 
    
-
-
    
-size()distance(begin(), end()) of the largest
-possible container
-
    
-
    • 
-
-
  • 
 
    
-Change the text in the Operational Semantics column in the row for
-"a.empty()" as follows:
+Against thread-safety:
+
    
+
    
+The thread-safe version is well-known to be far more expensive, even
+if used by a single thread.  Many applications, including all single-threaded
+ones, do not care.
 
    
 
-
    
-a.size() == 0a.begin() == a.end()
-
    
-
    • 
-
-
+
    [
+San Francisco:
+]
    
 
-
  • 
+
+
    
 
    
-In 23.2.1 [container.requirements.general] change Table 82 -- Allocator-aware container requirements as indicated:
+Beman: this is a complicated issue, and would like to move this to Open
+and await comment from Peter Dimov; we need very careful and complete
+rationale for any decision we make; let's go slow
 
    
-
-
      
-
    1. 
 
      
-Change the text in the Assertion/note column in the row for "X() /
-X u;" as follows:
+Detlef: I think that shared_ptr should not be thread-safe.
 
      
-
-
      
-Requires: A is DefaultConstructible post: u.size() ==
-0u.empty() == true, get_allocator() == A()
-
      
-
      2. 
-
-
    2. 
 
      
-Change the text in the Assertion/note column in the row for "X(m) /
-X u(m);" as follows:
+Hans: When you create a thread with a lambda, it in some cases makes it
+very difficult for the lambda to reference anything in the heap. It's
+currently ambiguous as to whether you can use a shared_ptr to get at an
+object.
 
      
-
-
      
-post: u.size() == 0u.empty() == true,
-get_allocator() == m
-
      
-
      3. 
-
    
-
    • 
-
-
  • 
 
    
-In 23.2.3 [sequence.reqmts] change Table 83 -- Sequence container requirements as indicated:
+Leave in Open. Detlef will submit an alternative proposed resolution
+that makes shared_ptr explicitly unsafe.
+
    
+
    
+A third option is to support both threadsafe and non-safe share_ptrs,
+and to let the programmer decide which behavior they want.
 
    
 
-
      
-
    1. 
 
      
-Change the text in the Assertion/note column in the row for "X(n,
-t) / X a(n, t)" as follows:
+Beman:  Peter, do you support the PR?
 
      
 
+
      
+Peter:
+
      
 
      
-post: size()distance(begin(), end()) == n [..]
-
      
-
      2. 
-
-
    2. 
 
      
-Change the text in the Assertion/note column in the row for "X(i,
-j) / X a(i, j)" as follows:
+Yes, I support the proposed resolution, and I certainly oppose any
+attempts to make shared_ptr thread-unsafe.
+
      
+
      
+I'd mildly prefer if
 
      
-
 
      
-[..] post: size() == distance between i and
-jdistance(begin(), end()) == distance(i, j) [..]
+[Note: This is true in spite of that fact that such functions often
+modify use_count() --end note]
 
      
-
      3. 
-
-
    3. 
 
      
-Change the text in the Assertion/note column in the row for
-"a.clear()" as follows:
+is changed to
 
      
 
      
-a.erase(a.begin(), a.end()) post:
-size() == 0a.empty() == true
+[Note: This is true in spite of that fact that such functions often
+cause a change in use_count() --end note]
 
      
-
      4. 
-
    
-
    • 
-
-
  • 
 
    
-In 23.2.4 [associative.reqmts] change Table 85 -- Associative container requirements as indicated:
+(or something along these lines) to emphasise that use_count() is not,
+conceptually, a variable, but a return value.
 
    
+
    • + +

    [ -Not every occurrence of size() was replaced, because all current -associative containers -have a size. The following changes ensure consistency regarding the -semantics of "erase" -for all tables and adds some missing objects +2009-07 Frankfurt ]

    -
      -
    1. +

      -Change the text in the Complexity column in the row for -"a.insert(i, j)" as follows: +Vote: Do we want one thread-safe shared pointer or two? If two, one +would allow concurrent construction and destruction of shared pointers, +and one would not be thread-safe. If one, then it would be thread-safe.

      -
      -N log(a.size() + N) (N is the distance from i to -j) where N == distance(i, j) -
      -
      2. - -

    2. -Change the text in the Complexity column in the row for -"a.erase(k)" as follows: +No concensus on that vote.

      -
      -log(a.size()) + a.count(k) -
      -
      3. - -

    3. -Change the text in the Complexity column in the row for -"a.erase(q1, q2)" as follows: +Hans to improve wording in consultation with Pete. Leave Open.

      - -
      -log(a.size()) + N where N is the distance from q1 -to q2 - == distance(q1, q2).
      -
      4. -
    4. -

      -Change the text in the Assertion/note column in the row for -"a.clear()" as follows: -

      +

      [ +2009-10 Santa Cruz: +]

      +
      -a.erase(a.begin(),a.end()) post: size() == -0a.empty() == true +Move to Ready. Ask Editor to clear up wording a little when integrating to +make it clear that the portion after the first comma only applies for +the presence of data races.
      -
      5. -
    5. -

      -Change the text in the Complexity column in the row for "a.clear()" -as follows: -

      +

      [ +2009-10-24 Hans adds: +]

      +
      -linear in a.size() -
      -
      6. +

      +I think we need to pull 896 back from ready, unfortunately. My wording +doesn't say the right thing. +

      -

    6. -Change the text in the Complexity column in the row for -"a.count(k)" as follows: +I suspect we really want to say something along the lines of:

      -log(a.size()) + a.count(k) +For purposes of determining the presence of a data race, member +functions access and modify only the shared_ptr and +weak_ptr objects themselves and not objects they refer to. +Changes in use_count() do not reflect modifications that can +introduce data races.
      -
      7. -
    - -

  • -In 23.2.5 [unord.req] change Table 87 -- Unordered associative container requirements as indicated: +But I think this needs further discussion by experts to make sure this +is right.

    -

    [ -The same rational as for Table 85 applies here -]

    - -
      -

    1. -Change the text in the Assertion/note column in the row for -"a.clear()" as follows: +Detlef and I agree continue to disagree on the resolution, but I think +we agree that it would be good to try to expedite this so that it can be +in CD2, since it's likely to generate NB comments no matter what we do. +And lack of clarity of intent is probably the worst option. I think it +would be good to look at this between meetings.

      - -
      -[..] Post: a.size() == 0empty() == true -
      -
      2. -
    -
    • - - - - - -
    -

    865. More algorithms that throw away information

    -

    Section: 25.4.6 [alg.fill], 25.4.7 [alg.generate] Status: Open - Submitter: Daniel Krügler Opened: 2008-07-13 Last modified: 2009-07-25

    -

    View all issues with Open status.

    -

    Discussion:

    +

    Proposed resolution:

    -In regard to library defect 488 I found some more algorithms which -unnecessarily throw away information. These are typically algorithms, -which sequentially write into an OutputIterator, but do not return the -final value of this output iterator. These cases are: +Make it explicitly thread-safe, in this weak sense, as I believe was intended:

    - -
      -
    1. -
      template<class OutputIterator, class Size, class T>
-void fill_n(OutputIterator first, Size n, const T& value);
      2. - -
    2. -
      template<class OutputIterator, class Size, class Generator>
-void generate_n(OutputIterator first, Size n, Generator gen);
      3. -

    -In both cases the minimum requirements on the iterator are -OutputIterator, which means according to the requirements of -24.2.3 [output.iterators]/2 that only single-pass iterations are guaranteed. -So, if users of fill_n and generate_n have *only* an OutputIterator -available, they have no chance to continue pushing further values -into it, which seems to be a severe limitation to me. +Insert in 20.8.15.2 [util.smartptr.shared], before p5:

    - -

    [ -Post Summit Daniel "conceptualized" the wording. -]

    - - -

    [ -Batavia (2009-05): -]

    -

    -Alisdair likes the idea, but has concerns about the specific wording -about the returns clauses. -

    -

    -Alan notes this is a feature request. -

    -

    -Bill notes we have made similar changes to other algorithms. +For purposes of determining the presence of a data race, +member functions do not modify const shared_ptr and +const weak_ptr arguments, nor any objects they +refer to. [Note: This is true in spite of that fact that such functions often +cause a change in use_count() --end note]

    +

    -Move to Open. +On looking at the text, I'm not sure we need a similar disclaimer +anywhere else, since nothing else has the problem with the modified +use_count(). I think Howard arrived at a similar conclusion.

    - - -

    [ -2009-07 Frankfurt -]

    - - -
    -We have a consensus for moving forward on this issue, but Daniel needs -to deconceptify it. -
    - -

    [ -2009-07-25 Daniel provided non-concepts wording. -]

    -

    Proposed resolution:

    -
      -
    1. +
      +

      900. stream move-assignment

      +

      Section: 27.9.1.8 [ifstream.assign] Status: Open + Submitter: Niels Dekker Opened: 2008-09-20 Last modified: 2009-10-20

      +

      View all issues with Open status.

      +

      Discussion:

      -Replace the current declaration of fill_n in 25 [algorithms]/2, header -<algorithm> synopsis and in 25.4.6 [alg.fill] by +It +appears that we have an issue similar to issue 675 regarding the move-assignment of +stream types. For example, when assigning to an std::ifstream, +ifstream1, it seems preferable to close the file originally held by +ifstream1:

      -
      template<class OutputIterator, class Size, class T>
-  voidOutputIterator fill_n(OutputIterator first, Size n, const T& value);
+
      ifstream1 = std::move(ifstream2); 
 
      
 
 
      
-Just after the effects clause add a new returns clause saying:
+The current Draft
+(N2723)
+specifies that the move-assignment of
+stream types like ifstream has the same effect as a swap:
 
      
 
 
      
-Returns: For fill_n and positive n, returns first + n. Otherwise
-returns first for fill_n.
-
      
-
      2. - -
    2. -

      -Replace the current declaration of generate_n in 25 [algorithms]/2, -header <algorithm> synopsis and in 25.4.7 [alg.generate] by -

      - -
      template<class OutputIterator, class Size, class Generator>
-  voidOutputIterator generate_n(OutputIterator first, Size n, Generator gen);
-
      -

      -Just after the effects clause add a new returns clause saying: +Assign and swap 27.9.1.8 [ifstream.assign]

      - +
      basic_ifstream& operator=(basic_ifstream&& rhs); 
+
      -For generate_n and positive n, returns first + n. Otherwise -returns first for generate_n. +Effects: swap(rhs). +
      -
      3. -
    - - - - - - - -
    -

    868. default construction and value-initialization

    -

    Section: 23 [containers] Status: Review - Submitter: Alberto Ganesh Barbati Opened: 2008-07-22 Last modified: 2009-07-19

    -

    View other active issues in [containers].

    -

    View all other issues in [containers].

    -

    View all issues with Review status.

    -

    Discussion:

    -

    -The term "default constructed" is often used in wording that predates -the introduction of the concept of value-initialization. In a few such -places the concept of value-initialization is more correct than the -current wording (for example when the type involved can be a built-in) -so a replacement is in order. Two of such places are already covered by -issue 867. This issue deliberately addresses the hopefully -non-controversial changes in the attempt of being approved more quickly. -A few other occurrences (for example in std::tuple, -std::reverse_iterator and std::move_iterator) are left to separate -issues. For std::reverse_iterator, see also issue 408. This issue is -related with issue 724. -

    [ -San Francisco: +Batavia (2009-05): ]

    -

    -The list provided in the proposed resolution is not complete. James -Dennett will review the library and provide a complete list and will -double-check the vocabulary. +Howard agrees with the analysis and the direction proposed.

    -This issue relates to Issue 886 tuple construction +Move to Open pending specific wording to be supplied by Howard.

    [ -2009-07 Frankfurt +2009-07 Frankfurt: ]

    -

    -The proposed resolution is incomplete. -

    -

    -Move to Tentatively NAD Future. Howard will contact Ganesh for wording. -If wording is forthcoming, Howard will move it back to Review. -

    +Howard is going to write wording.

    [ -2009-07-18 Ganesh updated the proposed wording. +2009-07-26 Howard provided wording. ]

    -
    -

    -Howard: Moved back to Review. Note that X [utility.arg.requirements] -refers to a section that is not in the current working paper, but does refer to -a section that we expect to reappear after the de-concepts merge. This was a -point of confusion we did not recognize when we reviewed this issue in Frankfurt. -

    -

    -Howard: Ganesh also includes a survey of places in the WP surveyed for changes -of this nature and purposefully not treated: -

    +

    [ +2009-09-13 Niels adds: +]

    +
    -

    -Places where changes are not being -proposed -

    -

    -In the following paragraphs, we are not proposing changes because -it's not clear whether we actually prefer value-initialization over -default-initialization (now partially covered by 1012): -

    -
      -

    • 20.8.9.2.1 [unique.ptr.single.ctor] para 3 e 7

      • -

    • 24.5.1.2.1 [reverse.iter.cons] para 1

      • -

    • 24.5.2.2.1 [move.iter.op.const] para 1

      • -
    -

    In the following paragraphs, the expression "default -constructed" need not be changed, because the relevant type does -not depend on a template parameter and has a user-provided -constructor:

    -
      -

    • [func.referenceclosure.invoke] para 12, type: - reference_closure

      • -

    • 30.3.1.2 [thread.thread.constr] para 30, type: thread

      • -

    • 30.3.1.5 [thread.thread.member] para 52, type: thread_id

      • -

    • 30.3.2 [thread.thread.this], para 1, type: thread_id

      • -
    +Note: The proposed change of 27.9.1.3 [filebuf.assign]/1 depends on the +resolution of LWG 1204, which allows implementations to assume that +*this and rhs refer to different objects.
    +

    [ +2009 Santa Cruz: +]

    + + +
    +Leave as Open. Too closely related to 911 to move on at this time.

    Proposed resolution:

    -

    -Change X [utility.arg.requirements] para 2: -

    - -
    -In general, a default constructor is -not required. Certain container class member function signatures -specify the default constructorT() -as a default argument. T() shall be a well-defined expression (8.5) -if one of those signatures is called using the default argument -(8.3.6). -

    -Change 23.3.2.1 [deque.cons] para 5: +Change 27.8.1.2 [stringbuf.assign]/1:

    +
    basic_stringbuf& operator=(basic_stringbuf&& rhs);
+
    -Effects: Constructs a deque with n -default constructedvalue-initialized -elements. +-1- Effects: swap(rhs). +After the move assignment *this reflects the same observable +state it would have if it had been move constructed from rhs +(27.8.1.1 [stringbuf.cons]). + +

    -Change 23.3.2.2 [deque.capacity] para 1: +Change 27.8.2.2 [istringstream.assign]/1:

    +
    basic_istringstream& operator=(basic_istringstream&& rhs);
+
    -Effects: If sz < size(), equivalent -to erase(begin() + sz, end());. If size() < sz, appends sz - -size() default -constructedvalue-initialized -elements to the sequence. +-1- Effects: swap(rhs). +Move assigns the base and members of *this with the respective +base and members of rhs. + +

    -Change 23.3.3.1 [forwardlist.cons] para 5: +Change 27.8.3.2 [ostringstream.assign]/1:

    +
    basic_ostringstream& operator=(basic_ostringstream&& rhs);
+
    -Effects: Constructs a forward_list object with n default -constructedvalue-initialized -elements. +-1- Effects: swap(rhs). +Move assigns the base and members of *this with the respective +base and members of rhs. + +

    -Change 23.3.3.4 [forwardlist.modifiers] para 21: +Change 27.8.5.1 [stringstream.assign]/1:

    +
    basic_stringstream& operator=(basic_stringstream&& rhs);
+
    -Effects: [...] For the first signature -the inserted elements are default -constructedvalue-initialized, -and for the second signature they are copies of c. +-1- Effects: swap(rhs). +Move assigns the base and members of *this with the respective +base and members of rhs. + +

    -Change 23.3.4.1 [list.cons] para 5: +Change 27.9.1.3 [filebuf.assign]/1:

    +
    basic_filebuf& operator=(basic_filebuf&& rhs);
+
    -Effects: Constructs a list with n default -constructedvalue-initialized -elements. +-1- Effects: swap(rhs). +Begins by calling this->close(). +After the move assignment *this reflects the same observable +state it would have if it had been move constructed from rhs +(27.9.1.2 [filebuf.cons]). + +

    -Change 23.3.4.2 [list.capacity] para 15: +Change 27.9.1.8 [ifstream.assign]/1:

    +
    basic_ifstream& operator=(basic_ifstream&& rhs);
+
    -Effects: If sz < size(), equivalent -to list<T>::iterator it = begin(); advance(it, sz); erase(it, -end());. If size() < sz, appends sz - size() default -constructedvalue-initialized -elements to the sequence. +-1- Effects: swap(rhs). +Move assigns the base and members of *this with the respective +base and members of rhs. +

    -Change 23.3.6.1 [vector.cons] para 3: +Change 27.9.1.12 [ofstream.assign]/1:

    +
    basic_ofstream& operator=(basic_ofstream&& rhs);
+
    -Effects: Constructs a vector with n -default constructedvalue-initialized -elements. +-1- Effects: swap(rhs). +Move assigns the base and members of *this with the respective +base and members of rhs. +

    -Change 23.3.6.2 [vector.capacity] para 24: +Change 27.9.1.16 [fstream.assign]/1:

    +
    basic_fstream& operator=(basic_fstream&& rhs);
+
    -Effects: If sz < size(), equivalent -to erase(begin() + sz, end());. If size() < sz, appends sz - -size() default -constructedvalue-initialized -elements to the sequence. +-1- Effects: swap(rhs). +Move assigns the base and members of *this with the respective +base and members of rhs. +
    @@ -13549,429 +10912,424 @@ elements to the sequence.
    -

    870. Do unordered containers not support function pointers for predicate/hasher?

    -

    Section: 23.2.5 [unord.req] Status: Open - Submitter: Daniel Krügler Opened: 2008-08-17 Last modified: 2009-07-28

    -

    View other active issues in [unord.req].

    -

    View all other issues in [unord.req].

    +

    910. Effects of MoveAssignable

    +

    Section: 20.2.1 [utility.arg.requirements] Status: Open + Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2009-11-03

    +

    View other active issues in [utility.arg.requirements].

    +

    View all other issues in [utility.arg.requirements].

    View all issues with Open status.

    Discussion:

    +

    Addresses UK 150

    +

    -Good ol' associative containers allow both function pointers and -function objects as feasible -comparators, as described in 23.2.4 [associative.reqmts]/2: +The description of the effect of operator= in the MoveAssignable +concept, given in paragraph 7 is:

    +
    result_type  T::operator=(T&&  rv);  // inherited from HasAssign<T, T&&>
+
    +
    -Each associative container is parameterized on Key and an ordering -relation Compare that -induces a strict weak ordering (25.3) on elements of Key. [..]. The -object of type Compare is -called the comparison object of a container. This comparison object -may be a pointer to -function or an object of a type with an appropriate function call operator.[..] +Postconditions: the constructed T object is equivalent to the value of +rv before the assignment. [Note: there is no +requirement on the value of rv after the assignment. --end note] +

    -The corresponding wording for unordered containers is not so clear, -but I read it to disallow -function pointers for the hasher and I miss a clear statement for the -equality predicate, see -23.2.5 [unord.req]/3+4+5: +The sentence contains a typo (what is the "constructed T object"?) +probably due to a cut&paste from MoveConstructible. Moreover, the +discussion of LWG issue 675 shows that the postcondition is too generic +and might not reflect the user expectations. An implementation of the +move assignment that just calls swap() would always fulfill the +postcondition as stated, but might have surprising side-effects in case +the source rvalue refers to an object that is not going to be +immediately destroyed. See LWG issue 900 for another example. Due to +the sometimes intangible nature of the "user expectation", it seems +difficult to have precise normative wording that could cover all cases +without introducing unnecessary restrictions. However a non-normative +clarification could be a very helpful warning sign that swapping is not +always the correct thing to do.

    -
    -

    -Each unordered associative container is parameterized by Key, by a -function object Hash that -acts as a hash function for values of type Key, and by a binary -predicate Pred that induces an -equivalence relation on values of type Key.[..] -

    -

    -A hash function is a function object that takes a single argument of -type Key and returns a -value of type std::size_t. -

    -

    -Two values k1 and k2 of type Key are considered equal if the -container's equality function object -returns true when passed those values.[..] -

    -
    +

    [ +2009-05-09 Alisdair adds: +]

    -

    -and table 97 says in the column "assertion...post-condition" for the -expression X::hasher: -

    -Hash shall be a unary function object type such that the expression -hf(k) has type std::size_t. -
    -

    -Note that 20.7 [function.objects]/1 defines as "Function objects are -objects with an operator() defined.[..]" +Issue 910 is exactly the reason BSI advanced the Editorial comment UK-150.

    -Does this restriction exist by design or is it an oversight? If an -oversight, I suggest that to apply -the following +The post-conditions after assignment are at a minimum that the object +referenced by rv must be safely destructible, and the transaction should not +leak resources. Ideally it should be possible to simply assign rv a new +valid state after the call without invoking undefined behaviour, but any +other use of the referenced object would depend upon additional guarantees +made by that type.

    +

    [ -2009-07-28 Reopened by Alisdair. No longer solved by concepts. +2009-05-09 Howard adds: ]

    - - -

    Proposed resolution:

    +

    -In 23.2.5 [unord.req]/3, just after the second sentence which is written as +The intent of the rvalue reference work is that the moved from rv is +a valid object. Not one in a singular state. If, for example, the moved from +object is a vector, one should be able to do anything on that moved-from +vector that you can do with any other vector. However you would +first have to query it to find out what its current state is. E.g. it might have capacity, +it might not. It might have a non-zero size, it might not. But regardless, +you can push_back on to it if you want.

    -
    -Additionally, unordered_map and unordered_multimap associate an -arbitrary mapped type T with the Key. -
    +

    +That being said, most standard code is now conceptized. That is, the concepts +list the only operations that can be done with templated types - whether or not +the values have been moved from. +

    -add one further sentence: +Here is user-written code which must be allowed to be legal:

    +
    #include <vector>
+#include <cstdio>
 
-
    
-Both Hash and Pred may be pointers to function or objects of a type
-with an appropriate function call operator.
-
    
+template <class Allocator>
+void
+inspect(std::vector<double, Allocator>&& v)
+{
+    std::vector<double, Allocator> result(move(v));
+    std::printf("moved from vector has %u size and %u capacity\n", v.size(), v.capacity());
+    std::printf("The contents of the vector are:\n");
+    typedef typename std::vector<double, Allocator>::iterator I;
+    for (I i = v.begin(), e = v.end(); i != e; ++i)
+        printf("%f\n", *i);
+}
+
+int main()
+{
+    std::vector<double> v1(100, 5.5);
+    inspect(move(v1));
+}
+

    -[Note1: Since the detailed requirements for Pred and Hash are given in -p.4 and p.5, it an alternative resolution -would be to insert a new paragraph just after p.5, which contains the -above proposed sentence] +The above program does not treat the moved-from vector as singular. It +only treats it as a vector with an unknown value.

    -[Note2: I do not propose a change of above quoted element in table 97, -because the mis-usage of the -notion of "function object" seems already present in the standard at -several places, even if it includes -function pointers, see e.g. 25 [algorithms]/7. The important point is -that in those places a statement is -given that the actually used symbol, like "Predicate" applies for -function pointers as well] +I believe the current proposed wording is consistent with my view on this.

    +
    - -

    Rationale:

    [ -San Francisco: +Batavia (2009-05): ]

    -
    -This is fixed by -N2776. +We agree that the proposed resolution +is an improvement over the current wording.
    +

    [ +2009-07 Frankfurt: +]

    - - - -
    -

    871. Iota's requirements on T are too strong

    -

    Section: 26.7.5 [numeric.iota] Status: Review - Submitter: Daniel Krügler Opened: 2008-08-20 Last modified: 2009-07-30

    -

    View all issues with Review status.

    -

    Discussion:

    -

    -According to the recent WP -N2691, -26.7.5 [numeric.iota]/1, the requires clause -of std::iota says: -

    -
    -T shall meet the requirements of CopyConstructible and Assignable types, and -shall be convertible to ForwardIterator's value type.[..] +Need to look at again without concepts.
    -

    -Neither CopyConstructible nor Assignable is needed, instead MoveConstructible -seems to be the correct choice. I guess the current wording resulted as an -artifact from comparing it with similar numerical algorithms like accumulate. -

    - -

    -Note: If this function will be conceptualized, the here proposed -MoveConstructible -requirement can be removed, because this is an implied requirement of -function arguments, see -N2710/[temp.req.impl]/3, last bullet. -

    -

    [ -post San Francisco: +2009-07 Frankfurt: ]

    -Issue pulled by author prior to review. +Walter will consult with Dave and Doug.

    [ -2009-07-30 Daniel reopened: +2009-10 Santa Cruz: ]

    -with the absence of concepts, this issue (closed) is valid again and I -suggest to reopen it. -I also revised by proposed resolution based on N2723 wording: +We believe this is handled by the resolution to issue 1204, +but there is to much going on in this area to be sure. Defer for now.

    Proposed resolution:

    -Change the first sentence of 26.7.5 [numeric.iota]/1: +In [concept.copymove], replace the postcondition in paragraph 7 with:

    -Requires: T shall meet the requirements of CopyConstructible and -Assignable types, and shall be -convertible to ForwardIterator's value type. [..] -
    - - - +Postconditions: *this is equivalent to the value of rv before the +assignment. [Note: there is no requirement on the value of rv after the +assignment, but the +effect should be unsurprising to the user even in case rv is not +immediately destroyed. This may require that resources previously owned +by *this are released instead of transferred to rv. -- end note] +
    -

    872. move_iterator::operator[] has wrong return type

    -

    Section: 24.5.2.2.12 [move.iter.op.index] Status: Open - Submitter: Doug Gregor Opened: 2008-08-21 Last modified: 2009-07-28

    +

    911. I/O streams and move/swap semantic

    +

    Section: 27.7.1 [input.streams], 27.7.2 [output.streams] Status: Open + Submitter: Alberto Ganesh Barbati Opened: 2008-09-29 Last modified: 2009-10-20

    View all issues with Open status.

    Discussion:

    -move_iterator's operator[] is declared as: +Class template basic_istream, basic_ostream and basic_iostream +implements public move constructors, move assignment operators and swap +method and free functions. This might induce both the user and the +compiler to think that those types are MoveConstructible, MoveAssignable +and Swappable. However, those class templates fail to fulfill the user +expectations. For example:

    -
    reference operator[](difference_type n) const;
+
    std::ostream os(std::ofstream("file.txt"));
+assert(os.rdbuf() == 0); // buffer object is not moved to os, file.txt has been closed
+
+std::vector<std::ostream> v;
+v.push_back(std::ofstream("file.txt"));
+v.reserve(100); // causes reallocation
+assert(v[0].rdbuf() == 0); // file.txt has been closed!
+
+std::ostream&& os1 = std::ofstream("file1.txt");
+os1 = std::ofstream("file2.txt");
+os1 << "hello, world"; // still writes to file1.txt, not to file2.txt!
+
+std::ostream&& os1 = std::ofstream("file1.txt");
+std::ostream&& os2 = std::ofstream("file2.txt");
+std::swap(os1, os2);
+os1 << "hello, world"; // writes to file1.txt, not to file2.txt!
 
    
 
 
    
-This has the same problem that reverse_iterator's operator[] used to
-have: if the underlying iterator's operator[] returns a proxy, the
-implicit conversion to value_type&& could end up referencing a temporary
-that has already been destroyed. This is essentially the same issue that
-we dealt with for reverse_iterator in DR 386.
+This is because the move constructor, the move assignment operator and
+swap are all implemented through calls to std::basic_ios member
+functions move() and swap() that do not move nor swap the controlled
+stream buffers. That can't happen because the stream buffers may have
+different types.
+
    
+
+
    
+Notice that for basic_streambuf, the member function swap() is
+protected. I believe that is correct and all of basic_istream,
+basic_ostream, basic_iostream should do the same as the move ctor, move
+assignment operator and swap member function are needed by the derived
+fstreams and stringstreams template. The free swap functions for
+basic_(i|o|io)stream templates should be removed for the same reason.
 
    
 
 
    [
-2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+Batavia (2009-05):
 ]
    
 
-
-
-
-
    Proposed resolution:
    
+
    
 
    
-In 24.5.2.1 [move.iterator] and 24.5.2.2.12 [move.iter.op.index], change the declaration of
-move_iterator's operator[] to:
+We note that the rvalue swap functions have already been removed.
 
    
+
    
+Bill is unsure about making the affected functions protected;
+he believes they may need to be public.
+
    
+
    
+We are also unsure about removing the lvalue swap functions as proposed.
+
    
+
    
+Move to Open.
+
    
+
    
 
-
    reference unspecified operator[](difference_type n) const;
-
    
-
-
-
-
    Rationale:
    
 
    [
-San Francisco:
+2009-07 Frankfurt:
 ]
    
 
 
 
    
-NAD Editorial, see
-N2777.
+
    
+It's not clear that the use case is compelling.
+
    
+
    
+Howard: This needs to be implemented and tested.
+
    
 
    
 
+
    [
+2009-07-26 Howard adds:
+]
    
 
 
-
-
    
-
    876. basic_string access operations should give stronger guarantees
    
-
    Section: 21.4 [basic.string] Status: Ready
- Submitter: Daniel Krügler Opened: 2008-08-22  Last modified: 2009-07-17
    
-
    View all other issues in [basic.string].
    
-
    View all issues with Ready status.
    
-
    Discussion:
    
-
    
-During the Sophia Antipolis meeting it was decided to split-off some
-parts of the
-n2647
-("Concurrency modifications for basic_string")
-proposal into a separate issue, because these weren't actually
-concurrency-related. The here proposed changes refer to the recent
-update document
-n2668
-and attempt to take advantage of the
-stricter structural requirements.
-
    
+
    
 
    
-Indeed there exists some leeway for more guarantees that would be
-very useful for programmers, especially if interaction with transactionary
-or exception-unaware C API code is important. This would also allow
-compilers to take advantage of more performance optimizations, because
-more functions can have throw() specifications. This proposal uses the
-form of "Throws: Nothing" clauses to reach the same effect, because
-there already exists a different issue in progress to clean-up the current
-existing "schizophrenia" of the standard in this regard.
+I started out thinking I would recommend NAD for this one.  I've turned around
+to agree with the proposed resolution (which I've updated to the current draft).
+I did not fully understand Ganesh's rationale, and attempt to describe my
+improved understanding below.
 
    
+
 
    
-Due to earlier support for copy-on-write, we find the following
-unnecessary limitations for C++0x:
+The move constructor, move assignment operator, and swap function are different
+for basic_istream, basic_ostream and basic_iostream
+than other classes.  A timely conversation with Daniel reminded me of this long
+forgotten fact.  These members are sufficiently different that they would be
+extremely confusing to use in general, but they are very much needed for derived
+clients.
 
    
 
-
      
+
        
 
      • 
-Missing no-throw guarantees: data() and c_str() simply return
-a pointer to their guts, which is a non-failure operation. This should
-be spelled out. It is also noteworthy to mention that the same
-guarantees should also be given by the size query functions,
-because the combination of pointer to content and the length is
-typically needed during interaction with low-level API.
+The move constructor moves everything but the rdbuf pointer.
 
        • 
 
      • 
-Missing complexity guarantees: data() and c_str() simply return
-a pointer to their guts, which is guaranteed O(1). This should be
-spelled out.
+The move assignment operator moves everything but the rdbuf pointer.
 
        • 
 
      • 
-Missing reading access to the terminating character: Only the
-const overload of operator[] allows reading access to the terminator
-char. For more intuitive usage of strings, reading access to this
-position should be extended to the non-const case. In contrast
-to C++03 this reading access should now be homogeneously
-an lvalue access.
+The swap function swaps everything but the rdbuf pointer.
 
        • 
-
    
+
 
 
    
-The proposed resolution is split into a main part (A) and a
-secondary part (B) (earlier called "Adjunct Adjunct Proposal").
-(B) extends (A) by also making access to index position
-size() of the at() overloads a no-throw operation. This was
-separated, because this part is theoretically observable in
-specifically designed test programs.
+The reason for this behavior is that for the std-derived classes (stringstreams,
+filestreams), the rdbuf pointer points back into the class itself
+(self referencing).  It can't be swapped or moved.  But this fact isn't born out
+at the stream level.  Rather it is born out at the fstream/sstream
+level.  And the lower levels just need to deal with that fact by not messing around
+with the rdbuf pointer which is stored down at the lower levels.
 
    
 
-
    [
-San Francisco:
-]
    
-
-
-
    
-
    
-We oppose part 1 of the issue but hope to address size() in
-issue 877.
-
    
-
    
-We do not support part B. 4 of the issue because of the breaking API change.
-
    
 
    
-We support part A. 2 of the issue.
+In a nutshell, it is very confusing for all of those who are not so intimately
+related with streams that they've implemented them.  And it is even fairly
+confusing for some of those who have (including myself).  I do not think it is
+safe to swap or move istreams or ostreams because this will
+(by necessary design) separate stream state from streambuffer state.  Derived
+classes (such as fstream and stringstream must be used to
+keep the stream state and stream buffer consistently packaged as one unit during
+a move or swap.
 
    
+
 
    
-On support part A. 3 of the issue:
+I've implemented this proposal and am living with it day to day.
 
    
-
    
-Pete's broader comment: now that we know that basic_string will be a
-block of contiguous memory, we should just rewrite its specification
-with that in mind. The expression of the specification will be simpler
-and probably more correct as a result.
-
    
+
 
    
 
 
    [
-2009-07 Frankfurt
+2009 Santa Cruz:
 ]
    
 
 
 
    
-
    
-Move proposed resolution A to Ready.
-
    
-
    [
-Howard: Commented out part B.
-]
    
-
+Leave Open.  Pablo expected to propose alternative wording which would rename
+move construction, move assignment and swap, and may or may not make them
+protected.  This will impact issue 900.
 
    
 
 
 
 
    Proposed resolution:
    
-
      
-
    1. 
-
        
-
      1. 
-
        In 21.4.4 [string.capacity], just after p. 1 add a new paragraph:
-
        
-
        
-Throws: Nothing.
-
        
-
-
        2. 
-
      2. 
 
        
-In 21.4.5 [string.access] replace p. 1 by the following 4 paragraghs:
+27.7.1.1 [istream]: make the following member functions protected:
 
        
 
-
        
+
        basic_istream(basic_istream&&  rhs);
+basic_istream&  operator=(basic_istream&&  rhs);
+void  swap(basic_istream&  rhs);
+
        
+
 
        
-Requires: pos ≤ size().
+Ditto: remove the swap free function signature
 
        
+
+
        // swap: 
+template <class charT, class traits> 
+  void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);
+
        
+
 
        
-Returns: If pos < size(), returns *(begin() + pos). Otherwise, returns
-a reference to a charT() that shall not be modified.
+27.7.1.1.2 [istream.assign]: remove paragraph 4
 
        
+
+
        template <class charT, class traits> 
+  void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);
+
        
+
        
+Effects: x.swap(y).
+
        
+
        
+
 
        
-Throws: Nothing.
+27.7.1.5 [iostreamclass]: make the following member function protected:
 
        
+
+
        basic_iostream(basic_iostream&&  rhs);
+basic_iostream&  operator=(basic_iostream&&  rhs);
+void  swap(basic_iostream&  rhs);
+
        
+
 
        
-Complexity: Constant time.
+Ditto: remove the swap free function signature
 
        
-
        
 
-
        3. 
-
      3. 
+
        template <class charT, class traits> 
+  void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);
+
        
+
 
        
-In 21.4.7.1 [string.accessors] replace the now common returns
-clause of c_str() and data() by the following three paragraphs:
+27.7.1.5.3 [iostream.assign]: remove paragraph 3
 
        
+
+
        template <class charT, class traits> 
+  void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);
+
        
 
        
+Effects: x.swap(y).
+
        
+
        
+
 
        
-Returns: A pointer p such that p+i == &operator[](i) for each i
-in [0, size()].
+27.7.2.1 [ostream]: make the following member function protected:
 
        
+
+
        basic_ostream(basic_ostream&&  rhs);
+basic_ostream&  operator=(basic_ostream&&  rhs);
+void  swap(basic_ostream&  rhs);
+
        
+
 
        
-Throws: Nothing.
+Ditto: remove the swap free function signature
 
        
+
+
        // swap: 
+template <class charT, class traits> 
+  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
+
        
+
 
        
-Complexity: Constant time.
+27.7.2.3 [ostream.assign]: remove paragraph 4 
 
        
-
    
-
-
-
 
-
+
    template <class charT, class traits> 
+  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
+
    
+
    
+Effects: x.swap(y).
+
    
+
    
 
 
 
@@ -13979,210 +11337,293 @@ in [0, size()].
 
 
 
    
-
    879. Atomic load const qualification
    
-
    Section: 29 [atomics] Status: Open
- Submitter: Alexander Chemeris Opened: 2008-08-24  Last modified: 2009-07-17
    
-
    View other active issues in [atomics].
    
-
    View all other issues in [atomics].
    
+
    915. minmax with initializer_list should return
+pair of T, not pair of const T&
    
+
    Section: 25.4.7 [alg.min.max] Status: Open
+ Submitter: Daniel Krügler Opened: 2008-10-04  Last modified: 2009-10-23
    
+
    View all other issues in [alg.min.max].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
 
    
-The atomic_address type and atomic<T*> specialization provide atomic
-updates to pointers.  However, the current specification requires
-that the types pointer be to non-const objects.  This restriction
-is unnecessary and unintended.
+It seems that the proposed changes for
+N2772
+were not clear enough in
+this point:
 
    
 
-
    [
-Summit:
-]
    
-
 
    
-Move to review.  Lawrence will first check with Peter whether the
-current examples are sufficient, or whether they need to be expanded to
-include all cases.
-
    
-
+25.4.7 [alg.min.max], before p.23 + p.24 + before p. 27 + p. 28 say that the return
+type of the minmax overloads with an initializer_list is
+pair<const T&, const T&>,
+which is inconsistent with the decision for the other min/max overloads which take
+a initializer_list as argument and return a T, not a const T&.
+Doing otherwise for minmax would easily lead to unexpected life-time
+problems by using minmax instead of min and max separately.
+
    + +

    [ +Batavia (2009-05): +]

    + +
    +We agree with the proposed resolution. +Move to Tentatively Ready. +
    +

    [ 2009-07 Frankfurt ]

    -

    -Lawrence will handle all issues relating to atomics in a single paper. -

    -

    -LWG will defer discussion on atomics until that paper appears. -

    -

    -Move to Open. -

    +Moved from Tentatively Ready to Open only because the wording needs to be +tweaked for concepts removal.
    +

    [ +2009-08-18 Daniel adds: +]

    -

    Proposed resolution:

    -

    -Add const qualification to the pointer values of the atomic_address -and atomic<T*> specializations. E.g. -

    - -
    typedef struct atomic_address {
-   void store(const void*, memory_order = memory_order_seq_cst) volatile;
-   void* exchange( const void*, memory_order = memory_order_seq_cst) volatile;
-   bool compare_exchange( const void*&, const void*,
-                          memory_order, memory_order) volatile;
-   bool compare_exchange( const void*&, const void*,
-                          memory_order = memory_order_seq_cst ) volatile;
-   void* operator=(const void*) volatile;
-} atomic_address;
-
-void atomic_store(volatile atomic_address*, const void*);
-void atomic_store_explicit(volatile atomic_address*, const void*,
-                          memory_order);
-void* atomic_exchange(volatile atomic_address*, const void*);
-void* atomic_exchange_explicit(volatile atomic_address*, const void*,
-                              memory_order);
-bool atomic_compare_exchange(volatile atomic_address*,
-                            const void**, const void*);
-bool atomic_compare_exchange_explicit(volatile atomic_address*,
-                                     const void**, const void*,
-                                     memory_order, memory_order);
-
    +
    +Recommend NAD since the proposed changes have already been performed +as part of editorial work of +N2914. +
    +

    [ +2009-10 Santa Cruz: +]

    +
    +Can't find initializer_list form of minmax anymore, only variadic +version. Seems like we had an editing clash with concepts. Leave Open, +at least until editorial issues resolved. Bring this to Editor's +attention. +
    -
    -

    880. Missing atomic exchange parameter

    -

    Section: 29 [atomics] Status: Open - Submitter: Lawrence Crowl Opened: 2008-08-24 Last modified: 2009-07-17

    -

    View other active issues in [atomics].

    -

    View all other issues in [atomics].

    -

    View all issues with Open status.

    -

    Duplicate of: 942

    -

    Discussion:

    + +

    Proposed resolution:

    +
      +

    1. -The atomic_exchange and atomic_exchange_explicit functions seem to -be inconsistently missing parameters. +In 25 [algorithms]/2, header <algorithm> synopsis change as indicated:

      -

      [ -Post Summit: -]

      - +
      template<classLessThanComparable T>
+requires CopyConstructible<T>
+pair<const T&, const T&>
+minmax(initializer_list<T> t);
 
-
      
+template<class T, classStrictWeakOrder<auto, T> Compare>
+requires CopyConstructible<T>
+pair<const T&, const T&>
+minmax(initializer_list<T> t, Compare comp);
+
      +
      2. +

    2. -Lawrence: Need to write up a list for Pete with details. +In 25.4.7 [alg.min.max] change as indicated (Begin: Just before p.20):

      +
      template<classLessThanComparable T>
+  requires CopyConstructible<T>
+  pair<const T&, const T&>
+  minmax(initializer_list<T> t);
+
      +

      -Detlef: Should not be New, we already talked about in Concurrency group. +-20- Requires: T is LessThanComparable and +CopyConstructible.

      -Recommend Open. +-21- Returns: pair<const T&, const +T&>(x, y) where x is the +smallest value and y the largest value in the initializer_list.

      -

      [ -2009-07 Frankfurt -]

      - +

      [..]

      +
      template<class T, classStrictWeakOrder<auto, T> Compare>
+  requires CopyConstructible<T>
+  pair<const T&, const T&>
+  minmax(initializer_list<T> t, Compare comp);
+

      -Lawrence will handle all issues relating to atomics in a single paper. -

      -

      -LWG will defer discussion on atomics until that paper appears. +-24- Requires: type T is LessThanComparable and CopyConstructible.

      -Move to Open. +-25- Returns: pair<const T&, const +T&>(x, y) where x is the +smallest value and y largest value in the initializer_list.

      +
      +
      3. +
    -

    Proposed resolution:

    + + + +
    +

    920. Ref-qualification support in the library

    +

    Section: 20.7.14 [func.memfn] Status: Ready + Submitter: Bronek Kozicki Opened: 2008-10-06 Last modified: 2009-10-23

    +

    View all other issues in [func.memfn].

    +

    View all issues with Ready status.

    +

    Duplicate of: 1230

    +

    Discussion:

    -Add the appropriate parameters. For example, +Daniel Krügler wrote:

    -
    bool atomic_exchange(volatile atomic_bool*, bool);
-bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
+
    
+
    
+Shouldn't above list be completed for &- and &&-qualified
+member functions This would cause to add:
+
    
+
    template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) &);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) const &);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) volatile &);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) &&);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) const &&);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
+template<Returnable R, class T, CopyConstructible... Args>
+unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
 
    
 
+
    
+
+
    
+yes, absolutely. Thanks for spotting this. Without this change mem_fn
+cannot be initialized from pointer to ref-qualified member function. I
+believe semantics of such function pointer is well defined.
+
    
 
+
    [
+Post Summit Daniel provided wording.
+]
    
 
 
+
    [
+Batavia (2009-05):
+]
    
 
-
    
-
    881. shared_ptr conversion issue
    
-
    Section: 20.8.10.2.1 [util.smartptr.shared.const] Status: Ready
- Submitter: Peter Dimov Opened: 2008-08-30  Last modified: 2009-07-17
    
-
    View other active issues in [util.smartptr.shared.const].
    
-
    View all other issues in [util.smartptr.shared.const].
    
-
    View all issues with Ready status.
    
-
    Discussion:
    
+
    
+
    
+We need to think about whether we really want to go down the proposed path
+of combinatorial explosion.
+Perhaps a Note would suffice.
+
    
+
    
+We would really like to have an implementation before proceeding.
+
    
 
    
-We've changed shared_ptr<Y> to not convert to shared_ptr<T> when Y*
-doesn't convert to T* by resolving issue 687. This only fixed the
-converting copy constructor though.
-N2351
-later added move support, and
-the converting move constructor is not constrained.
+Move to Open, and recommend this be deferred until after the next
+Committee Draft has been issued.
 
    
+
    
 
 
    [
-San Francisco:
+2009-10-10 Daniel updated wording to post-concepts.
 ]
    
 
 
 
    
-We might be able to move this to NAD, Editorial once shared_ptr is
-conceptualized, but we want to revisit this issue to make sure.
+1230 has a similar proposed resolution
 
    
 
 
    [
-2009-07 Frankfurt
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
      
+
    1. 
 
      
-Moved to Ready.
+Change 20.7 [function.objects]/2, header
+<functional> synopsis as follows:
 
      
+
+
      // 20.7.14, member function adaptors:
+template<class R, class T> unspecified mem_fn(R T::*);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...));
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) &);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const &);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) &&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const &&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
+
      
+
      2. 
+
+
    2. 
 
      
-This issue now represents the favored format for specifying constrained templates.
+Change the prototype list of 20.7.14 [func.memfn] as follows [NB: The
+following text, most notably p.2 and p.3 which
+discuss influence of the cv-qualification on the definition of the
+base class's first template parameter remains
+unchanged. ]:
 
      
-
    +
    template<class R, class T> unspecified mem_fn(R T::* pm);
 
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...));
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile);
 
-
    Proposed resolution:
    
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) &);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const &);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) &&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const &&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
+
    + + +

  • -We need to change the Requires clause of the move constructor: +Remove 20.7.14 [func.memfn]/5:

    -
    shared_ptr(shared_ptr&& r); 
-template<class Y> shared_ptr(shared_ptr<Y>&& r); 
-
    -Requires Remarks: For the second constructor Y* shall be -convertible to T*. - -The second constructor shall not participate in overload resolution -unless Y* is convertible to T*. - +Remarks: Implementations may implement mem_fn as a set of +overloaded function templates.
    -
    - -

    -in order to actually make the example in 687 compile -(it now resolves to the move constructor). -

    +
    • + @@ -14190,728 +11631,703 @@ in order to actually make the example in 883. swap circular definition -

    Section: 23 [containers] Status: Ready - Submitter: Alisdair Meredith Opened: 2008-09-10 Last modified: 2009-07-17

    -

    View other active issues in [containers].

    -

    View all other issues in [containers].

    +

    921. Rational Arithmetic should use template aliases

    +

    Section: 20.4.1 [ratio.ratio] Status: Ready + Submitter: Pablo Halpern Opened: 2008-10-07 Last modified: 2009-10-21

    +

    View all other issues in [ratio.ratio].

    View all issues with Ready status.

    Discussion:

    +

    +The compile-time functions that operate on ratio<N,D> require the +cumbersome and error-prone "evaluation" of a type member using a +meta-programming style that predates the invention of template aliases. +Thus, multiplying three ratios a, b, and c requires the expression: +

    + +
    ratio_multiply<a, ratio_multiply<b, c>::type>::type
+

    -Note in particular that Table 90 "Container Requirements" gives -semantics of a.swap(b) as swap(a,b), yet for all -containers we define swap(a,b) to call a.swap(b) - a -circular definition. +The simpler expression: +

    + +
    ratio_multiply<a, ratio_multiply<b, c>>
+
    + +

    +Could be used by if template aliases were employed in the definitions.

    [ -San Francisco: +Post Summit: ]

    -Robert to propose a resolution along the lines of "Postcondition: "a = -b, b = a" This will be a little tricky for the hash containers, since -they don't have operator==. +

    +Jens: not a complete proposed resolution: "would need to make similar change" +

    +

    +Consensus: We agree with the direction of the issue. +

    +

    +Recommend Open. +

    [ -Post Summit Anthony Williams provided proposed wording. -]

    - - -

    [ -2009-07 Frankfurt +2009-05-11 Daniel adds: ]

    -Moved to Ready with minor edits (which have been made). +

    +Personally I'm not in favor for the addition of: +

    +
    typedef ratio type;
+
    +

    +For a reader of the +standard it's usage or purpose is unclear. I haven't seen similar examples +of attempts to satisfy non-feature complete compilers. +

    +

    [ +2009-05-11 Pablo adds: +]

    -

    Proposed resolution:

    +

    -In table 80 in section 23.2.1 [container.requirements.general], -replace the postcondition of a.swap(b) with the following: +The addition of type to the ratio template allows the previous style +(i.e., in the prototype implementations) to remain valid and permits the +use of transitional library implementations for C++03 compilers. I do +not feel strongly about its inclusion, however, and leave it up to the +reviewers to decide.

    +
    + +

    [ +Batavia (2009-05): +]

    - - - - - - - - - - - - - - - - - - - - - - - -
    Table 80 -- Container requirements
    ExpressionReturn typeOperational semanticsAssertion/note pre-/post-conidtionComplexity
    ...............
    a.swap(b);void swap(a,b) -Exchange the contents of a and b.(Note A)
    +Bill asks for additional discussion in the issue +that spells out more details of the implementation. +Howard points us to issue 948 +which has at least most of the requested details. +Tom is strongly in favor of overflow-checking at compile time. +Pete points out that there is no change of functionality implied. +We agree with the proposed resolution, +but recommend moving the issue to Review +to allow time to improve the discussion if needed.
    -

    -Remove the reference to swap from the paragraph following the table. -

    +

    [ +2009-07-21 Alisdair adds: +]

    +
    -Notes: the algorithms swap(), equal() and -lexicographical_compare() are defined in Clause 25. ... +See 1121 for a potentially incompatible proposal.
    +

    [ +2009-10 Santa Cruz: +]

    + +
    +Move to Ready. +
    -
    -

    885. pair assignment

    -

    Section: 20.3.3 [pairs] Status: Open - Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2009-07-17

    -

    View other active issues in [pairs].

    -

    View all other issues in [pairs].

    -

    View all issues with Open status.

    -

    Discussion:

    -
    20.2.3 pairs
-Missing assignemnt operator:
-template<class U , class V>
-  requires CopyAssignable<T1, U> && CopyAssignable<T2, V>
-    pair& operator=(pair<U , V> const & p );
-
    +

    Proposed resolution:

    + +
      +

    1. -Well, that's interesting. This assignment operator isn't in the -current working paper, either. Perhaps we deemed it acceptable to -build a temporary of type pair from pair<U, V>, then move-assign -from that temporary? +In 20.4 [ratio]/3 change as indicated: +

      + +
      // ratio arithmetic
+template <class R1, class R2> structusing ratio_add = see below;
+template <class R1, class R2> structusing ratio_subtract = see below;
+template <class R1, class R2> structusing ratio_multiply = see below;
+template <class R1, class R2> structusing ratio_divide = see below;
+
      +
      2. +
    2. +

      +In 20.4.1 [ratio.ratio], change as indicated:

      +
      namespace std {
+  template <intmax_t N, intmax_t D = 1>
+  class ratio {
+  public:
+    typedef ratio type;
+    static const intmax_t num;
+    static const intmax_t den;
+  };
+}
+
      +
      3. +

    3. -It sounds more like an issue waiting to be opened, unless you want to plug -it now. As written we risk moving from lvalues. +In 20.4.2 [ratio.arithmetic] change as indicated:

      -

      [ -San Francisco: -]

      - +
      template <class R1, class R2> structusing ratio_add = see below{
+  typedef see below type;
+};
+

      -Would be NAD if better ctors fixed it. +1 The nested typedef type ratio_add<R1, R2> +shall be a synonym for ratio<T1, T2> +where T1 has the value R1::num * R2::den + R2::num * R1::den and T2 +has the value R1::den * R2::den.

      +
      +
      +
      template <class R1, class R2> structusing ratio_subtract = see below{
+  typedef see below type;
+};
+
      +

      -Related to 811. +2 The nested typedef type ratio_subtract<R1, R2> +shall be a synonym for ratio<T1, T2> +where T1 has the value R1::num * R2::den - R2::num * R1::den and T2 +has the value R1::den * R2::den.

      - -

      [ -post San Francisco: -]

      - - +
      +
      template <class R1, class R2> structusing ratio_multiply = see below{
+  typedef see below type;
+};
+
      -Possibly NAD Editorial, solved by -N2770. +

      +3 The nested typedef type ratio_multiply<R1, R2> +shall be a synonym for ratio<T1, T2> +where T1 has the value R1::num * R2::num and T2 has the value R1::den * R2::den. +

      - -

      [ -2009-05-25 Alisdair adds: -]

      - - +
      +
      template <class R1, class R2> structusing ratio_divide = see below{
+  typedef see below type;
+};
+
      -Issue 885 was something I reported while reviewing the library concepts -documents ahead of San Francisco. The missing operator was added as part of -the paper adopted at that meeting -(N2770) -and I can confirm this operator is -present in the current working paper. I recommend NAD. +

      +4 The nested typedef type ratio_divide<R1, R2> +shall be a synonym for ratio<T1, T2> +where T1 has the value R1::num * R2::den and T2 has the value R1::den * R2::num. +

      - -

      [ -2009-07 Frankfurt -]

      - - +
      +
      4. +
    4. +

      +In 20.9.3.1 [time.duration.cons]/4 change as indicated: +

      -We agree with the intent, but we need to wait for the dust to settle on concepts. +

      +Requires: treat_as_floating_point<rep>::value shall be true or +ratio_divide<Period2, period>::type::den shall be 1.[..] +

      - - - -

      Proposed resolution:

      +
      5. +
    5. +

      +In 20.9.3.7 [time.duration.cast]/2 change as indicated: +

      +

      +Returns: Let CF be ratio_divide<Period, typename +ToDuration::period>::type, and [..]

      +
      +
      6. +
    -

    886. tuple construction

    -

    Section: 20.5.2.1 [tuple.cnstr] Status: Ready - Submitter: Alisdair Meredith Opened: 2008-09-15 Last modified: 2009-07-17

    -

    View other active issues in [tuple.cnstr].

    -

    View all other issues in [tuple.cnstr].

    -

    View all issues with Ready status.

    +

    929. Thread constructor

    +

    Section: 30.3.1.2 [thread.thread.constr] Status: Review + Submitter: Anthony Williams Opened: 2008-10-23 Last modified: 2009-10-25

    +

    View other active issues in [thread.thread.constr].

    +

    View all other issues in [thread.thread.constr].

    +

    View all issues with Review status.

    Discussion:

    -

    -20.5.2.1 [tuple.cnstr]: -

    -
    -Effects: Default initializes each element. -
    -

    -Could be clarified to state each "non-trivial" element. Otherwise -we have a conflict with Core deinfition of default initialization - -trivial types do not get initialized (rather than initialization -having no effect) -

    +

    Addresses UK 323

    -I'm going to punt on this one, because it's not an issue that's -related to concepts. I suggest bringing it to Howard's attention on -the reflector. +The thread constructor for starting a new thread with a function and +arguments is overly constrained by the signature requiring rvalue +references for func and args and the CopyConstructible requirements +for the elements of args. The use of an rvalue reference for the +function restricts the potential use of a plain function name, since +the type of the bound parameter will be deduced to be a function +reference and decay to pointer-to-function will not happen. This +therefore complicates the implementation in order to handle a simple +case. Furthermore, the use of rvalue references for args prevents the +array to pointer decay. Since arrays are not CopyConstructible or even +MoveConstructible, this essentially prevents the passing of arrays as +parameters. In particular it prevents the passing of string literals. +Consequently a simple case such as

    -

    [ -San Francisco: -]

    - +
    void f(const char*);
+std::thread t(f,"hello");
+
    -

    -Text in draft doesn't mean anything, changing to "non-trivial" makes it -meaningful. +is ill-formed since the type of the string literal is const char[6].

    +

    -We prefer "value initializes". Present implementations use -value-initialization. Users who don't want value initialization have -alternatives. +By changing the signature to take all parameters by value we can +eliminate the CopyConstructible requirement and permit the use of +arrays, as the parameter passing semantics will cause the necessary +array-to-pointer decay. They will also cause the function name to +decay to a pointer to function and allow the implementation to handle +functions and function objects identically.

    +

    -Request resolution text from Alisdair. +The new signature of the thread constructor for a function and +arguments is thus:

    +
    template<typename F,typename... Args>
+thread(F,Args... args);
+
    +

    -This issue relates to Issue 868 default construction and value-initialization. +Since the parameter pack Args can be empty, the single-parameter +constructor that takes just a function by value is now redundant.

    -

    [ -2009-05-04 Alisdair provided wording and adds: +Howard adds: ]

    -Note: This IS a change of semantic from TR1, although one the room agreed -with during the discussion. To preserve TR1 semantics, this would have been -worded: +I agree with everything Anthony says in this issue. However I believe we +can optimize in such a way as to get the pass-by-value behavior with the +pass-by-rvalue-ref performance. The performance difference is that the latter +removes a move when passing in an lvalue.

    -
    requires DefaultConstructible<Types>... tuple();
-
    -
    --2- Effects: Default-initializes each non-trivial element. -
    -
    - - -
    - -

    [ -2009-07 Frankfurt -]

    +

    +This circumstance is very analogous to make_pair (20.3.4 [pairs]) +where we started with passing by const reference, changed to pass by value to +get pointer decay, and then changed to pass by rvalue reference, but modified with +decay<T> to retain the pass-by-value behavior. If we were to +apply the same solution here it would look like: +

    +
    template <class F> explicit thread(F f);
+template <class F, class ...Args> thread(F&& f, Args&&... args);
+
    -Move to Ready. -
    - - - -

    Proposed resolution:

    -Change p2 in Construction 20.5.2.1 [tuple.cnstr]: +-4- Requires: F and each Ti in Args shall be CopyConstructible +if an lvalue and otherwise MoveConstructible. +INVOKE(f, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for +some values w1, w2, ... , wN, where N == sizeof...(Args).

    - -
    requires DefaultConstructible<Types>... tuple();
-
    -

    --2- Effects: Default Value-initializes each element. +-5- Effects: Constructs an object of type thread +and executes INVOKE(f, t1, t2, ..., tN) in a new +thread of execution, where t1, t2, ..., tN are the values in args.... +Constructs +the following objects in memory which is accessible to a new thread of execution +as if: +

    +
    typename decay<F>::type g(std::forward<F>(f));
+tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);
+
    +

    +The new thread of +execution executes INVOKE(g, wi...) where the wi... refers +to the elements stored in the tuple w. +Any return value from g is ignored. +If f terminates with an uncaught exception, std::terminate() shall be called. +If the evaluation of INVOKE(g, wi...) terminates +with an uncaught exception, std::terminate() shall be called [Note: +std::terminate() could be called before entering g. -- end note]. Any +exception thrown before the evaluation of INVOKE has started shall be +catchable in the calling thread.

    - - - - - -
    -

    887. issue with condition::wait_...

    -

    Section: 30.5.1 [thread.condition.condvar] Status: Open - Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-07-26

    -

    View other active issues in [thread.condition.condvar].

    -

    View all other issues in [thread.condition.condvar].

    -

    View all issues with Open status.

    -

    Discussion:

    -The Posix/C++ working group has identified an inconsistency between -Posix and the C++ working draft in that Posix requires the clock to be -identified at creation, whereas C++ permits identifying the clock at the -call to wait. The latter cannot be implemented with the former. +Text referring to when terminate() is called was contributed by Ganesh.

    +
    +

    [ -San Francisco: +Batavia (2009-05): ]

    -
    -

    -Howard recommends NAD with the following explanation: -

    - -

    -The intent of the current wording is for the condtion_variable::wait_until -be able to handle user-defined clocks as well as clocks the system knows about. -This can be done by providing overloads for the known clocks, and another -overload for unknown clocks which synchs to a known clock before waiting. -For example: -

    - -
    template <class Duration>
-bool
-condition_variable::wait_until(unique_lock<mutex>& lock,
-                               const chrono::time_point<chrono::system_clock, Duration>& abs_time)
-{
-    using namespace chrono;
-    nanoseconds d = __round_up<nanoseconds>(abs_time.time_since_epoch());
-    __do_timed_wait(lock.mutex()->native_handle(), time_point<system_clock, nanoseconds>(d));
-    return system_clock::now() < abs_time;
-}
-
-template <class Clock, class Duration>
-bool
-condition_variable::wait_until(unique_lock<mutex>& lock,
-                               const chrono::time_point<Clock, Duration>& abs_time)
-{
-    using namespace chrono;
-    typename Clock::time_point  c_entry = Clock::now();
-    system_clock::time_point    s_entry = system_clock::now();
-    nanoseconds dn = __round_up<nanoseconds>(abs_time.time_since_epoch() -
-                                              c_entry.time_since_epoch());
-    __do_timed_wait(lock.mutex()->native_handle(), s_entry + dn);
-    return Clock::now() < abs_time;
-}
-
    - -

    -In the above example, system_clock is the only clock which the underlying -condition variable knows how to deal with. One overload just passes that clock -through. The second overload (approximately) converts the unknown clock into -a system_clock time_point prior to passing it down to the native -condition variable. -

    - -

    -On Posix systems vendors are free to add implementation defined constructors which -take a clock. That clock can be stored in the condition_variable, and converted -to (or not as necessary) as shown above. -

    - -

    -If an implementation defined constructor takes a clock (for example), then part -of the semantics for that implementation defined ctor might include that a -wait_until using a clock other than the one constructed with results -in an error (exceptional condition) instead of a conversion to the stored clock. -Such a design is up to the vendor as once an implementation defined ctor is used, -the vendor is free to specifiy the behavior of waits and/or notifies however -he pleases (when the cv is constructed in an implementation defined manner). -

    +We agree with the proposed resolution, +but would like the final sentence to be reworded +since "catchable" is not a term of art (and is used nowhere else).

    [ -Post Summit: +2009-07 Frankfurt: ]

    -"POSIX people will review the proposed NAD resolution at their upcoming NY -meeting. +This is linked to +N2901.

    -

    -See the minutes at: http://wiki.dinkumware.com/twiki/bin/view/Posix/POSIX-CppBindingWorkingGroupNewYork2009. +Howard to open a separate issue to remove (1176). +

    +

    +In Frankfurt there is no consensus for removing the variadic constructor.

    [ -2009-07 Frankfurt +2009-10 Santa Cruz: ]

    -Move to NAD. +We want to move forward with this issue. If we later take it out via 1176 +then that's ok too. Needs small group to improve wording.

    [ -2009-07-18 Detlef reopens the issue: +2009-10 Santa Cruz: ]

    -On Friday afternoon in Frankfurt is was decided that 887 is NAD. -This decision was mainly based on a sample implementation presented -by Howard that implemented one clock on top of another. -Unfortunately this implementation doesn't work for the probably most -important case where a system has a monotonic clock and a real-time -clock (or "wall time" clock): +Stefanus provided revised wording. Moved to Review Here is the original wording:

    +

    -If the underlying "system_clock" is a monotonic clock, and -the program waits on the real-time clock, and the real-time clock -is set forward, the wait will unblock too late. +Modify the class definition of std::thread in 30.3.1 [thread.thread.class] to remove the +following signature:

    +
    template<class F> explicit thread(F f);
+template<class F, class ... Args> explicit thread(F&& f, Args&& ... args);
+
    +

    -If the underlying "system_clock" is a real-time clock, and the -program waits on the monotonic clock, and the real-time clock -is set back, the wait again will unblock too late. +Modify 30.3.1.2 [thread.thread.constr] to replace the constructors prior to paragraph 4 with +the single constructor as above. Replace paragraph 4 - 6 with the +following:

    +

    -Sorry that I didn't remember this on Friday, but it was Friday -afternoon after a busy week... +-4- Requires: F and each Ti in Args shall be CopyConstructible +if an lvalue and otherwise MoveConstructible. +INVOKE(f, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for +some values w1, w2, ... , wN, where N == sizeof...(Args).

    -

    -So as the decision was made on a wrong asumption, I propose to re-open -the issue. +-5- Effects: Constructs an object of type thread +and executes INVOKE(f, t1, t2, ..., tN) in a new +thread of execution, where t1, t2, ..., tN are the values in args.... +Constructs +the following objects: +

    +
    typename decay<F>::type g(std::forward<F>(f));
+tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);
+
    +

    +and executes INVOKE(g, wi...) in a new thread of execution. +These objects shall be destroyed when the new thread of execution completes. +Any return value from g is ignored. +If f terminates with an uncaught exception, std::terminate() shall be called. +If the evaluation of INVOKE(g, wi...) terminates +with an uncaught exception, std::terminate() shall be called [Note: +std::terminate() could be called before entering g. -- end note]. Any +exception thrown before the evaluation of INVOKE has started shall be +catchable in the calling thread. +

    +

    +-6- Synchronization: The invocation of the constructor happens before the +invocation of f g.

    -

    [ -2009-07-26 Howard adds: -]

    +
    +
    -
    +

    Proposed resolution:

    -Detlef correctly argues that condition_variable::wait_until could -return "too late" in the context of clocks being adjusted during the wait. I agree -with his logic. But I disagree that this makes this interface unimplementable -on POSIX. +Modify the class definition of std::thread in 30.3.1 [thread.thread.class] to remove the +following signature:

    +
    template<class F> explicit thread(F f);
+template<class F, class ... Args> explicit thread(F&& f, Args&& ... args);
+
    +

    -The POSIX spec also does not guarantee that pthread_cond_timedwait does -not return "too late" when clocks are readjusted during the wait. Indeed, the -POSIX specification lacks any requirements at all concerning how soon -pthread_cond_timedwait returns after a time out. This is evidently a -QOI issue by the POSIX standard. Here is a quote of the most relevant normative -text concerning pthread_cond_timedwait found -here. +Modify 30.3.1.2 [thread.thread.constr] to replace the constructors prior to paragraph 4 with +the single constructor as above. Replace paragraph 4 - 6 with the +following:

    -The pthread_cond_timedwait() function shall be equivalent to -pthread_cond_wait(), except that an error is returned if the absolute -time specified by abstime passes (that is, system time equals or exceeds -abstime) before the condition cond is signaled or broadcasted, or if the -absolute time specified by abstime has already been passed at the time -of the call. -
    -

    -I.e. the POSIX specification speaks of the error code returned in case of a time -out, but not on the timeliness of that return. +-4- Requires: F and each Ti in Args +shall be CopyConstructible if an lvalue and +otherwise MoveConstructible. INVOKE(f, w1, w2, +..., wN) (20.7.2 [func.require]) shall be a valid expression +for some values w1, w2, ... , wN, where N == +sizeof...(Args).

    -Might this simply be an oversight, or minor defect in the POSIX specification? +-5- Effects: Constructs an object of type thread and executes +INVOKE(f, t1, t2, ..., tN) in a new thread of execution, where +t1, t2, ..., tN are the values in args.... +Given a function as follows: +Any return +value from f is ignored. If f terminates with an +uncaught exception, std::terminate() shall be called.

    -

    -I do not believe so. This same section goes on to say in non-normative -text: -

    +
    
+template<typename T> typename decay<T>::type decay_copy(T&& v)
+    { return std::forward<T>(v); }
+
    -
    -For cases when the system clock is advanced discontinuously by an -operator, it is expected that implementations process any timed wait -expiring at an intervening time as if that time had actually occurred. -
    +

    +The new thread of execution executes INVOKE(decay_copy(f), +decay_copy(args)...) with the calls to decay_copy() being evaluated in +the constructing thread. Any return value from this invocation is +ignored. [Note: this implies any exceptions not thrown from the +invocation of the copy of f will be thrown in the constructing thread, +not the new thread. — end note]. +

    -Here is non-normative wording encouraging the implementation to ignore an advancing -underlying clock and subsequently causing an early (spurious) return. There is -no wording at all which addresses Detlef's example of a "late return". With -pthread_cond_timedwait this would be caused by setting the system clock -backwards. It seems reasonable to assume, based on the wording that is already -in the POSIX spec, that again, the discontinuously changed clock would be ignored -by pthread_cond_timedwait. +-6- Synchronization: The invocation of the constructor happens before the +invocation of copy of f.

    +
    -

    -A noteworthy difference between pthread_cond_timedwait and -condition_variable::wait_until is that the POSIX spec appears to -say that ETIMEDOUT should be returned if pthread_cond_timedwait -returns because of timeout signal, whether or not the system clock was discontinuously -advanced during the wait. In contrast condition_variable::wait_until -always returns: -

    - -
    Clock::now() < abs_time
-
    - -

    -That is, the C++ spec requires that the clock be rechecked (detecting discontinuous -adjustments during the wait) at the time of return. condition_variable::wait_until -may indeed return early or late. But regardless it will return a value -reflecting timeout status at the time of return (even if clocks have been adjusted). -Of course the clock may be adjusted after the return value is computed but before the client has -a chance to read the result of the return. Thus there are no iron-clad guarantees -here. -

    - -

    -condition_variable::wait_until (and pthread_cond_timedwait) -is little more than a convenience function for making sure -condition_variable::wait doesn't hang for an unreasonable amount of -time (where the client gets to define "unreasonable"). I do not think it -is in anyone's interest to try to make it into anything more than that. -

    - -

    -I maintain that this is a useful and flexible specification in the spirit of -C++, and is implementable on POSIX. The implementation technique described above -is a reasonable approach. There may also be higher quality approaches. This -specification, like the POSIX specification, gives a wide latitude for QOI. -

    - -

    -I continue to recommend NAD, but would not object to a clarifying note regarding -the behavior of condition_variable::wait_until. At the moment, I do -not have good wording for such a note, but welcome suggestions. -

    - - - - - -

    Proposed resolution:

    -

    -

    -

    889. thread::id comparisons

    -

    Section: 30.3.1.1 [thread.thread.id] Status: Review - Submitter: Lawrence Crowl Opened: 2008-09-15 Last modified: 2009-07-28

    -

    View all other issues in [thread.thread.id].

    -

    View all issues with Review status.

    +

    932. unique_ptr(pointer p) for pointer deleter types

    +

    Section: 20.8.14.2.1 [unique.ptr.single.ctor] Status: Ready + Submitter: Howard Hinnant Opened: 2008-11-26 Last modified: 2009-10-22

    +

    View other active issues in [unique.ptr.single.ctor].

    +

    View all other issues in [unique.ptr.single.ctor].

    +

    View all issues with Ready status.

    Discussion:

    -

    Addresses UK 324

    +

    Addresses US 79

    -The thread::id type supports the full set of comparison operators. This -is substantially more than is required for the associative containers that -justified them. Please place an issue against the threads library. +20.8.14.2.1 [unique.ptr.single.ctor]/5 no longer requires for D +not to be a pointer type. I believe this restriction was accidently removed +when we relaxed the completeness reuqirements on T. The restriction +needs to be put back in. Otherwise we have a run time failure that could +have been caught at compile time:

    +
    {
+unique_ptr<int, void(*)(void*)> p1(malloc(sizeof(int)));  // should not compile
+}  // p1.~unique_ptr() dereferences a null function pointer
+unique_ptr<int, void(*)(void*)> p2(malloc(sizeof(int)), free);  // ok
+
    +

    [ -San Francisco: +Post Summit: ]

    -

    -Would depend on proposed extension to POSIX, or non-standard extension. -What about hash? POSIX discussing op. POSIX not known to be considering -support needed for hash, op. -

    -

    -Group expresses support for putting ids in both unordered and ordered containers. -

    +Recommend Tentatively Ready.

    [ -post San Francisco: +2009-07 Frankfurt ]

    -

    -Howard: It turns out the current working paper -N2723 -already has hash<thread::id> -(20.7 [function.objects], 20.7.17 [unord.hash]). We simply -overlooked it in the meeting. It is a good thing we voted in favor of it -(again). :-) -

    -

    -Recommend NAD. -

    - +Moved from Tentatively Ready to Open only because the wording needs to be +improved for enable_if type constraining, possibly following Robert's +formula.

    [ -Post Summit: +2009-07 Frankfurt: ]

    -Recommend to close as NAD. For POSIX, see if we need to add a function to -convert pthread_t to integer. +

    +We need to consider whether some requirements in the Requires paragraphs +of [unique.ptr] should instead be Remarks. +

    +

    +Leave Open. Howard to provide wording, and possibly demonstrate how this +can be implemented using enable_if. +

    [ -Post Summit, Alisdair adds: +2009-07-27 Howard adds: ]

    -The recommendation for LWG-889/UK-324 is NAD, already specified. -

    -

    -It is not clear to me that the specification is complete. -

    -

    -In particular, the synopsis of <functional> in 20.7 [function.objects] does not mention hash< thread::id -> nor hash< error_code >, although their -existence is implied by 20.7.17 [unord.hash], p1. -

    -

    -I am fairly uncomfortable putting the declaration for the -thread_id specialization into <functional> as -id is a nested class inside std::thread, so it implies -that <functional> would require the definition of the -thread class template in order to forward declared -thread::id and form this specialization. +The two constructors to which this issue applies are not easily constrained +with enable_if as they are not templated:

    + +
    unique_ptr();
+explicit unique_ptr(pointer p);
+
    +

    -It seems better to me that the dependency goes the other way around -(<thread> will more typically make use of -<functional> than vice-versa) and the -hash<thread::id> specialization be declared in the -<thread> header. +To "SFINAE" these constructors away would take heroic effort such as specializing +the entire unique_ptr class template on pointer deleter types. There +is insufficient motivation for such heroics. Here is the expected and +reasonable implementation for these constructors:

    + +
    unique_ptr()
+    : ptr_(pointer())
+    {
+        static_assert(!is_pointer<deleter_type>::value,
+            "unique_ptr constructed with null function pointer deleter");
+    }
+explicit unique_ptr(pointer p)
+    : ptr_(p)
+    {
+        static_assert(!is_pointer<deleter_type>::value,
+            "unique_ptr constructed with null function pointer deleter");
+    }
+
    +

    -I think hash<error_code> could go into either -<system_error> or <functional> and have no -immediate preference either way. However, it should clearly appear in -the synopsis of one of these two. +I.e. just use static_assert to verify that the constructor is not +instantiated with a function pointer for a deleter. The compiler will automatically +take care of issuing a diagnostic if the deleter is a reference type (uninitialized +reference error).

    +

    -Recommend moving 889 back to open, and tying in a reference to UK-324. +In keeping with our discussions in Frankfurt, I'm moving this requirement on +the implementation from the Requires paragraph to a Remarks paragraph.

    +

    [ -Batavia (2009-05): +2009-08-17 Daniel adds: ]

    +
    -Howard observes that thread::id need not be a nested class; -it could be a typedef for a more visible type. +

    +It is insufficient to require a diagnostic. This doesn't imply an +ill-formed program +as of 1.3.3 [defns.diagnostic] (a typical alternative would be a compiler +warning), but +exactly that seems to be the intend. I suggest to use the following +remark instead: +

    + +
    +Remarks: The program shall be ill-formed if this constructor is +instantiated when D is a pointer type or reference type.
    -

    [ -2009-05-24 Alisdair adds: -]

    +

    +Via the general standard rules of 1.4 [intro.compliance] the "diagnostic +required" is implied. +

    -
    -I do not believe this is correct. thread::id is explicitly documents as a -nested class, rather than as an unspecified typedef analogous to an -iterator. If the intent is that this is not implemented as a nested class -(under the as-if freedoms) then this is a novel form of standardese.

    [ -2009-07 Frankfurt +2009-10 Santa Cruz: ]

    -Decided we want to move hash specialization for thread_id to the thread -header. Alisdair to provide wording. +Moved to Ready.
    -

    [ -2009-07-28 Alisdair provided wording, moved to Review. -]

    - -

    Proposed resolution:

    -Add to 30.3 [thread.threads], p1 Header <thread> synopsis: -

    - -
    template <class T> struct hash;
-template <> struct hash<thread::id>;
-
    - -

    -Add template specialization below class definition in 30.3.1.1 [thread.thread.id] +Change the description of the default constructor in 20.8.14.2.1 [unique.ptr.single.ctor]:

    -
    template <>
-struct hash<thread::id> : public unary_function<thread::id, size_t> {
-   size_t operator()(thread::id val) const;
-};
-
    - +
    unique_ptr();
+
    +

    -Extend note in p2 30.3.1.1 [thread.thread.id] with second sentence: +-1- Requires: D shall be default constructible, and that construction +shall not throw an exception. D shall +not be a reference type or pointer type (diagnostic required).

    +

    ...

    +

    +Remarks: The program shall be ill-formed if this constructor is +instantiated when D is a pointer type or reference type. -

    -[Note: Relational operators allow thread::id objects to be used -as keys in associative containers. -hash template specialization allow thread::id objects to be used as keys -in unordered containers. -— end note] +

    +

    -Add new paragraph to end of 30.3.1.1 [thread.thread.id] +Add after 20.8.14.2.1 [unique.ptr.single.ctor]/8:

    -
    template <> struct hash<thread::id>;
+
    unique_ptr(pointer p);
 
    
-
    
-An explicit specializations of the class template hash (20.7.17 [unord.hash])
-shall be provided for the values of type thread::id
-suitable for use as keys in unordered associative containers (23.5 [unord]).
-
    
+
    
+
    ...
    
+
    
+Remarks: The program shall be ill-formed if this constructor is
+instantiated when D is a pointer type or reference type.
+
+
    
+
    
 
    
 
 
@@ -14919,224 +12335,185 @@ suitable for use as keys in unordered associative containers (23.5 [unord]).
 
 
 
    
-
    891. std::thread, std::call_once issue
    
-
    Section: 30.3.1.2 [thread.thread.constr], 30.4.5.2 [thread.once.callonce] Status: Open
- Submitter: Peter Dimov Opened: 2008-09-15  Last modified: 2009-07-17
    
-
    View other active issues in [thread.thread.constr].
    
-
    View all other issues in [thread.thread.constr].
    
-
    View all issues with Open status.
    
+
    939. Problem with std::identity and reference-to-temporaries
    
+
    Section: 20.3.3 [forward] Status: Ready
+ Submitter: Alisdair Meredith Opened: 2008-12-11  Last modified: 2009-10-29
    
+
    View all other issues in [forward].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
-I notice that the vararg overloads of std::thread and std::call_once
-(N2723 30.3.1.2 [thread.thread.constr] and 30.4.5.2 [thread.once.callonce]) are no longer specified in terms of
-std::bind; instead, some of the std::bind wording has been inlined into
-the specification.
-
    
+std::identity takes an argument of type T const &
+and returns a result of T const &.
+
    
 
    
-There are two problems with this.
+Unfortunately, this signature will accept a value of type other than T that
+is convertible-to-T, and then return a reference to the dead temporary.  The
+constraint in the concepts version simply protects against returning
+reference-to-void.
 
    
 
    
-First, the specification (and implementation) in terms of std::bind allows, for example:
+Solutions:
 
    
-
-
    std::thread th( f, 1, std::bind( g ) );
+
    
+
    
+i/  Return-by-value, potentially slicing bases and rejecting non-copyable
+types
+
    
+
    
+ii/ Provide an additional overload:
+
    
+
    template< typename T >
+template operator( U & ) = delete;
 
    
-
 
    
-which executes f( 1, g() ) in a thread. This can be useful. The
-"inlined" formulation changes it to execute f( 1, bind(g) ) in a thread.
+This seems closer on intent, but moves beyond the original motivation for
+the operator, which is compatibility with existing (non-standard)
+implementations.
 
    
 
    
-Second, assuming that we don't want the above, the specification has copied the wording
+iii/ Remove the operator() overload.  This restores the original definition
+of the identity, although now effectively a type_trait rather than part of
+the perfect forwarding protocol.
 
    
-
-
    
-INVOKE(func, w1, w2, ..., wN) (20.6.2) shall be a valid
-expression for some values w1, w2, ..., wN
-
    
-
 
    
-but this is not needed since we know that our argument list is args; it should simply be
+iv/ Remove std::identity completely; its original reason to exist is
+replaced with the IdentityOf concept.
 
    
-
-
    
-INVOKE(func, args...) (20.6.2) shall be a valid expression
 
    
+
    
+My own preference is somewhere between (ii) and (iii) - although I stumbled
+over the issue with a specific application hoping for resolution (i)!
+
    
 
 
    [
-Summit:
+Batavia (2009-05):
 ]
    
 
-
 
    
-Move to open.
+
    
+We dislike options i and iii, and option ii seems like overkill.
+If we remove it (option iv), implementers can still provide it under a
+different name.
+
    
+
    
+Move to Open pending wording (from Alisdair) for option iv.
+
    
 
    
 
 
    [
-Post Summit Anthony provided proposed wording.
+2009-05-23 Alisdair provided wording for option iv.
 ]
    
 
 
 
    [
-2009-07 Frankfurt
+2009-07-20 Alisdair adds:
 ]
    
 
 
 
    
-Leave Open. Await decision for thread variadic constructor.
+
    
+I'm not sure why this issue was not discussed at Frankfurt (or I missed
+the discussion) but the rationale is now fundamentally flawed.  With the
+removal of concepts, std::identity again becomes an important library
+type so we cannot simply remove it.
+
    
+
    
+At that point, we need to pick one of the other suggested resolutions,
+but have no guidance at the moment.
+
    
 
    
 
+
    [
+2009-07-20 Howard adds:
+]
    
 
 
-
    Proposed resolution:
    
+
    
 
    
-Change paragraph 4 of 30.3.1.2 [thread.thread.constr] to:
+I believe the rationale for not addressing this issue in Frankfurt was that it did
+not address a national body comment.
 
    
-
-
    
-
    template <class F> explicit thread(F f);
-template <class F, class ...Args> thread(F&& f, Args&&... args);
-
    
-
    
--4- Requires: F and each Ti in Args
-shall be CopyConstructible if an lvalue and otherwise
-MoveConstructible. INVOKE(f, w1, w2, ..., wN args...)
-(20.6.2) shall be a valid expression for some values w1, w2, ...,
-wN, where N == sizeof...(Args).
-
    
-
    
-
 
    
-Change paragraph 1 of 30.4.5.2 [thread.once.callonce] to:
+I also believe that removal of identity is still a practical option as
+my latest reformulation of forward, which is due to comments suggested
+at Summit, no longer uses identity. :-)
 
    
 
-
    template<class Callable, class ...Args> 
-  void call_once(once_flag& flag, Callable func, Args&&... args);
-
    
-
    
--1- Requires: The template parameters Callable> and each
-Ti in Args shall be CopyConstructible if an
-lvalue and otherwise MoveConstructible. INVOKE(func,
-w1, w2, ..., wN args...) (20.6.2) shall be a
-valid expression for some values w1, w2, ..., wN, where
-N == sizeof...(Args).
-
    
-
    
+
    template <class T, class U,
+    class = typename enable_if
+            <
+                !is_lvalue_reference<T>::value || 
+                 is_lvalue_reference<T>::value &&
+                 is_lvalue_reference<U>::value
+            >::type,
+    class = typename enable_if
+            <
+                is_same<typename remove_all<T>::type,
+                        typename remove_all<U>::type>::value
+            >::type>
+inline
+T&&
+forward(U&& t)
+{
+    return static_cast<T&&>(t);
 
+}
+
    
 
+
    [
+The above code assumes acceptance of 1120 for the definition of
+remove_all.  This is just to make the syntax a little more palatable.
+Without this trait the above is still very implementable.
+]
    
 
 
+
    
 
-
    
-
    893. std::mutex issue
    
-
    Section: 30.4.1.1 [thread.mutex.class] Status: Review
- Submitter: Peter Dimov Opened: 2008-09-15  Last modified: 2009-07-31
    
-
    View other active issues in [thread.mutex.class].
    
-
    View all other issues in [thread.mutex.class].
    
-
    View all issues with Review status.
    
-
    Duplicate of: 905
    
-
    Discussion:
    
-
    
-30.4.1.1 [thread.mutex.class]/27 (in
-N2723)
-says that the behavior is undefined if:
-
    
-
      
-
    • a thread that owns a mutex object calls lock() or
-try_lock() on that object
      • 
-
    
-
    
-I don't believe that this is right. Calling lock() or try_lock() on a
-locked mutex is well defined in the general case. try_lock() is required
-to fail and return false. lock() is required to either throw an
-exception (and is allowed to do so if it detects deadlock) or to block
-until the mutex is free. These general requirements apply regardless of
-the current owner of the mutex; they should apply even if it's owned by
-the current thread.
-
    
 
    
-Making double lock() undefined behavior probably can be justified (even
-though I'd still disagree with the justification), but try_lock() on a
-locked mutex must fail.
+Paper with rationale is on the way ... really, I promise this time! ;-)
 
    
+
    
 
 
    [
-Summit:
+2009-07-30 Daniel adds:  See 823 for an alternative resolution.
 ]
    
 
-
    
-
    
-Move to open. Proposed resolution:
-
    
-
      
-
    • 
-In 30.4.1 [thread.mutex.requirements] paragraph 12, change the error
-condition for resource_deadlock_would_occur to: "if the implementation
-detects that a deadlock would occur"
-
      • 
-
    • 
-Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2 "a thread that owns a mutex object
-calls lock() or try_lock() on that object, or"
-
      • 
-
    
-
    
 
 
    [
-2009-07 Frankfurt
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-Move to Review. Alisdair to provide note.
+Move to Ready. Howard will update proposed wording to reflect current draft.
 
    
 
-
    [
-2009-07-31 Alisdair provided note.
-]
    
-
 
 
 
    Proposed resolution:
    
 
    
-In 30.4.1 [thread.mutex.requirements] paragraph 12 change:
+Strike from 20.3 [utility]:
 
    
 
-
    
-
      
-
    • ...
      • 
-
    • 
-resource_deadlock_would_occur -- if the current thread already owns the mutex and is able 
-to detect it implementation detects that a deadlock would occur.
-
      • 
-
    • ...
      • 
-
    
-
    
+
    template <class T> struct identity;
+
    
 
 
    
-Strike 30.4.1.1 [thread.mutex.class] paragraph 3 bullet 2:
+Remove from 20.3.3 [forward]:
 
    
+
 
    
-
    
--3- The behavior of a program is undefined if:
-
    
-
      
-
    • ...
      • 
-
    • 
-a thread that owns a mutex object calls lock() or try_lock() on that object, or
-
      • 
-
    • ...
      • 
-
    
-
    
+
    template <class T> struct identity {
+  typedef T type;
 
-
    
-Add the following note after p3 30.4.1.1 [thread.mutex.class]
-
    
+  const T& operator()(const T& x) const;
+};    
 
+const T& operator()(const T& x) const;
+
    
 
    
-[Note: a program may deadlock if the thread that owns a mutex
-object calls lock() or try_lock() on that object. If the program can
-detect the deadlock, a resource_deadlock_would_occur error condition may
-be observed. — end note]
+-2-  Returns: x
+
    
 
    
 
 
@@ -15145,504 +12522,545 @@ be observed. — end note]
 
 
 
    
-
    896. Library thread safety issue
    
-
    Section: 20.8.10.2 [util.smartptr.shared] Status: Open
- Submitter: Hans Boehm Opened: 2008-09-16  Last modified: 2009-07-17
    
-
    View other active issues in [util.smartptr.shared].
    
-
    View all other issues in [util.smartptr.shared].
    
-
    View all issues with Open status.
    
+
    940. std::distance
    
+
    Section: 24.4.4 [iterator.operations] Status: Ready
+ Submitter: Thomas Opened: 2008-12-14  Last modified: 2009-10-22
    
+
    View other active issues in [iterator.operations].
    
+
    View all other issues in [iterator.operations].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
    
-It is unclear whether shared_ptr is thread-safe in the sense that
-multiple threads may simultaneously copy a shared_ptr.  However this
-is a critical piece of information for the client, and it has significant
-impact on usability for many applications.  (Detlef Vollman thinks it
-is currently clear that it is not thread-safe.  Hans Boehm thinks
-it currently requires thread safety, since the use_count is not an
-explicit field, and constructors and assignment take a const reference
-to an existing shared_ptr.)
-
    
+
+
    Addresses UK 270
    
 
 
    
-Pro thread-safety:
-
    
-
    
-Many multi-threaded usages are impossible.  A thread-safe version can
-be used to destroy an object when the last thread drops it, something
-that is often required, and for which we have no other easy mechanism.
+Regarding the std::distance - function, 24.4.4 [iterator.operations]
+/ 4 says:
 
    
+
    
+Returns the
+number of increments or decrements needed to get from first to last.
+
    
 
    
-Against thread-safety:
+This sentence is completely silent about the sign of the return value.
+24.4.4 [iterator.operations] / 1 gives more information about the
+underlying operations, but
+again no inferences about the sign can be made.
+Strictly speaking, that is taking that sentence literally, I think this
+sentence even implies a positive return value in all cases, as the
+number of increments or decrements is clearly a ratio scale variable,
+with a natural zero bound.
 
    
 
    
-The thread-safe version is well-known to be far more expensive, even
-if used by a single thread.  Many applications, including all single-threaded
-ones, do not care.
+Practically speaking, my implementations did what common sense and
+knowledge based on pointer arithmetic forecasts, namely a positive sign
+for increments (that is, going from first to last by operator++), and a
+negative sign for decrements (going from first to last by operator--).
 
    
-
-
    [
-San Francisco:
-]
    
-
-
-
    
 
    
-Beman: this is a complicated issue, and would like to move this to Open
-and await comment from Peter Dimov; we need very careful and complete
-rationale for any decision we make; let's go slow
+Here are my two questions:
 
    
 
    
-Detlef: I think that shared_ptr should not be thread-safe.
+First, is that paragraph supposed to be interpreted in the way what I
+called 'common sense', that is negative sign for decrements ? I am
+fairly sure that's the supposed behavior, but a double-check here in
+this group can't hurt.
 
    
 
    
-Hans: When you create a thread with a lambda, it in some cases makes it
-very difficult for the lambda to reference anything in the heap. It's
-currently ambiguous as to whether you can use a shared_ptr to get at an
-object.
+Second, is the present wording (2003 standard version - no idea about
+the draft for the upcoming standard) worth an edit to make it a bit more
+sensible, to mention the sign of the return value explicitly ?
 
    
+
+
    [
+Daniel adds:
+]
    
+
+
+
    
 
    
-Leave in Open. Detlef will submit an alternative proposed resolution
-that makes shared_ptr explicitly unsafe.
+My first thought was that resolution 204 would already cover the
+issue report, but it seems that current normative wording is in
+contradiction to that resolution:
 
    
+
 
    
-A third option is to support both threadsafe and non-safe share_ptrs,
-and to let the programmer decide which behavior they want.
+Referring to
+N2798,
+24.4.4 [iterator.operations]/ p.4 says:
 
    
 
+
    
+Effects: Returns the number of increments or decrements needed to get
+from first to last.
+
    
+
 
    
-Beman:  Peter, do you support the PR?
+IMO the part " or decrements" is in contradiction to p. 5 which says
 
    
 
+
    
+Requires: last shall be reachable from first.
+
    
+
 
    
-Peter:
+because "reachable" is defined in X [iterator.concepts]/7 as
 
    
+
 
    
+An iterator j is called reachable from an iterator i if and only if
+there is a finite
+sequence of applications of the expression ++i that makes i == j.[..]
+
    
+
 
    
-Yes, I support the proposed resolution, and I certainly oppose any
-attempts to make shared_ptr thread-unsafe.
+Here is wording that would be consistent with this definition of "reachable":
 
    
+
 
    
-I'd mildly prefer if
+Change 24.4.4 [iterator.operations] p4 as follows:
 
    
+
 
    
-[Note: This is true in spite of that fact that such functions often
-modify use_count() --end note]
+Effects: Returns the number of increments or decrements
+needed to get from first to last.
 
    
-
    
-is changed to
-
    
-
    
-[Note: This is true in spite of that fact that such functions often
-cause a change in use_count() --end note]
+
 
    
+
 
    
-(or something along these lines) to emphasise that use_count() is not,
-conceptually, a variable, but a return value.
+Thomas adds more discussion and an alternative view point
+here.
 
    
-
    
 
+
    [
+Summit:
+]
    
+
+
+
    
+The proposed wording below was verbally agreed to.  Howard provided.
 
    
 
 
    [
-2009-07 Frankfurt
+Batavia (2009-05):
 ]
    
 
-
 
    
 
    
-Vote: Do we want one thread-safe shared pointer or two? If two, one
-would allow concurrent construction and destruction of shared pointers,
-and one would not be thread-safe. If one, then it would be thread-safe.
-
    
-
    
-No concensus on that vote.
+Pete reports that a recent similar change has been made
+for the advance() function.
 
    
 
    
-Hans to improve wording in consultation with Pete. Leave Open.
+We agree with the proposed resolution.
+Move to Tentatively Ready.
 
    
 
    
 
+
    [
+2009-07 Frankfurt
+]
    
 
 
-
    Proposed resolution:
    
-
    
-Make it explicitly thread-safe, in this weak sense, as I believe was intended:
-
    
-
    
-Insert in 20.8.10.2 [util.smartptr.shared], before p5:
-
    
 
    
-
    
-For purposes of determining the presence of a data race,
-member functions do not modify const shared_ptr and
-const weak_ptr arguments, nor any objects they
-refer to.  [Note: This is true in spite of that fact that such functions often
-cause a change in use_count() --end note]
-
    
+Moved from Tentatively Ready to Open only because the wording needs to be
+tweaked for concepts removal.
 
    
-
    
-On looking at the text, I'm not sure we need a similar disclaimer
-anywhere else, since nothing else has the problem with the modified
-use_count().  I think Howard arrived at a similar conclusion.
-
    
 
+
    [
+2009-07 Frankfurt:
+]
    
 
 
+
    
+Leave Open pending arrival of a post-Concepts WD.
+
    
 
+
    [
+2009-10-14 Daniel provided de-conceptified wording.
+]
    
 
-
    
-
    897. Forward_list issues... Part 2
    
-
    Section: 23.3.3.4 [forwardlist.modifiers] Status: Review
- Submitter: Howard Hinnant Opened: 2008-09-22  Last modified: 2009-07-18
    
-
    View all issues with Review status.
    
-
    Discussion:
    
-
    
-This issue was split off from 892 at the request of the LWG.
-
    
 
 
    [
-San Francisco:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-
    
-This issue is more complicated than it looks.
-
    
-
    
-paragraph 47: replace each (first, last) with (first, last]
-
    
-
    
-add a statement after paragraph 48 that complexity is O(1)
-
    
-
    
-remove the complexity statement from the first overload of splice_after
-
    
-
    
-We may have the same problems with other modifiers, like erase_after.
-Should it require that all iterators in the range (position, last] be
-dereferenceable?
-
    
+Move to Ready, replacing the Effects clause in the proposed wording with
+"If InputIterator meets the requirements of random access iterator then
+returns (last - first), otherwise returns the number of increments
+needed to get from first to list.".
 
    
 
-
    
-There are actually 3 issues here:
-
    
 
+
+
    Proposed resolution:
    
 
      
 
    1. 
 
      
-What value should erase_after return?  With list, code often
-looks like:
-
      
-
      for (auto i = l.begin(); i != l.end();)
-{
-    // inspect *i and decide if you want to erase it
-    // ...
-    if (I want to erase *i)
-        i = l.erase(i);
-    else
-        ++i;
-}
-
      
-
      
-I.e. the iterator returned from erase is useful for setting up the
-logic for operating on the next element.  For forward_list this might
-look something like:
+Change 24.2.5 [random.access.iterators], Table 105 as indicated [This change is not
+essential but it simplifies the specification] for the row with
+expression "b - a"
+and the column Operational semantics:
 
      
-
      auto i = fl.before_begin();
-auto ip1 = i;
-for (++ip1; ip1 != fl.end(); ++ip1)
-{
-    // inspect *(i+1) and decide if you want to erase it
-    // ...
-    if (I want to erase *(i+1))
-        i = fl.erase_after(i);
-    else
-        ++i;
-    ip1 = i;
-}
+
+
      (a < b) ? distance(a,b)
+: -distance(b,a)
 
      
-
      
-In the above example code, it is convenient if erase_after returns
-the element prior to the erased element (range) instead of the element
-after the erase element (range).
-
      
-
      
-Existing practice:
-
      
-
        
-
      • SGI slist returns an iterator referencing the element after the erased range.
        • 
-
      • CodeWarrior slist returns an iterator referencing the element before the erased range.
        • 
-
      
-
      
-There is not a strong technical argument for either solution over the other.
-
      
 
      2. 
 
 
    2. 
 
      
-With all other containers, operations always work on the range
-[first, last) and/or prior to the given position.
-
      
-
      
-With forward_list, operations sometimes work on the range
-(first, last] and/or after the given position.
-
      
-
      
-This is simply due to the fact that in order to operate on
-*first (with forward_list) one needs access to
-*(first-1).  And that's not practical with
-forward_list.  So the operating range needs to start with (first,
-not [first (as the current working paper says). 
-
      
-
      
-Additionally, if one is interested in  splicing the range (first, last),
-then (with forward_list), one needs practical (constant time) access to
-*(last-1) so that one can set the next field in this node to
-the proper value.  As this is not possible with forward_list, one must
-specify the last element of interest instead of one past the last element of
-interest.  The syntax for doing this is to pass (first, last] instead
-of (first, last).
+Change 24.4.4 [iterator.operations]/4+5 as indicated:
 
      
+
+
      template<class InputIterator>
+  typename iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last);
+
      
+
      
 
      
-With erase_after we have a choice of either erasing the range
-(first, last] or (first, last).  Choosing the latter
-enables:
+4 Effects: If InputIterator meets the requirements
+of random access iterator then returns (last - first),
+otherwise Rreturns the number of increments
+or decrements needed to get from first to
+last.
 
      
-
      x.erase_after(pos, x.end());
-
      
 
 
      
-With the former, the above statement is inconvenient or expensive due to the lack
-of constant time access to x.end()-1.  However we could introduce:
+5 Requires: If InputIterator meets the requirements
+of random access iterator then last shall be reachable from
+first or first shall be reachable from last,
+otherwise last shall be reachable from first.
 
      
+
      
+
      
+
      3. 
+
    
 
-
    iterator erase_to_end(const_iterator position);
-
    
 
-
    
-to compensate.
-
    
 
-
    
-The advantage of the former ((first, last]) for erase_after
-is a consistency with splice_after which uses (first, last]
-as the specified range.  But this either requires the addition of erase_to_end
-or giving up such functionality.
-
    
 
-
 
-
  • 
-As stated in the discussion of 892, and reienforced by point 2 above,
-a splice_after should work on the source range (first, last]
-if the operation is to be Ο(1).  When splicing an entire list x the
-algorithm needs (x.before_begin(), x.end()-1].  Unfortunately x.end()-1
-is not available in constant time unless we specify that it must be.  In order to
-make x.end()-1 available in constant time, the implementation would have
-to dedicate a pointer to it.  I believe the design of
-N2543
-intended a nominal overhead of foward_list of 1 pointer.  Thus splicing
-one entire forward_list into another can not be Ο(1).
-
    • 
-
 
-
    [
-Batavia (2009-05):
-]
    
 
-
    
-
    
-We agree with the proposed resolution.
-
    
+
+
+
    
+
    950. unique_ptr converting ctor shouldn't accept array form
    
+
    Section: 20.8.14.2.1 [unique.ptr.single.ctor] Status: Ready
+ Submitter: Howard Hinnant Opened: 2009-01-07  Last modified: 2009-10-21
    
+
    View other active issues in [unique.ptr.single.ctor].
    
+
    View all other issues in [unique.ptr.single.ctor].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-Move to Review.
+unique_ptr's of array type should not convert to
+unique_ptr's which do not have an array type.
 
    
-
    
+
+
    struct Deleter
+{
+   void operator()(void*) {}
+};
+
+int main()
+{
+   unique_ptr<int[], Deleter> s;
+   unique_ptr<int, Deleter> s2(std::move(s));  // should not compile
+}
+
    
 
 
    [
-2009-07 Frankfurt
+Post Summit:
 ]
    
 
 
 
    
 
    
-We may need a new issue to correct splice_after, because it may no
-longer be correct to accept an rvalues as an argument. Merge may be
-affected, too. This might be issue 1133. (Howard: confirmed)
-
    
-
    
-Move this to Ready, but the Requires clause of the second form of
-splice_after should say "(first, last)," not "(first, last]" (there are
-three occurrences). There was considerable discussion on this. (Howard: fixed)
-
    
-
    
-Alan suggested removing the "foward_last<T. Alloc>&& x"
-parameter from the second form of splice_after, because it is redundant.
-PJP wanted to keep it, because it allows him to check for bad ranges
-(i.e. "Granny knots").
-
    
-
    
-We prefer to keep x.
+Walter: Does the "diagnostic required" apply to both arms of the "and"?
 
    
 
    
-Beman. Whenever we deviate from the customary half-open range in the
-specification, we should add a non-normative comment to the standard
-explaining the deviation. This clarifies the intention and spares the
-committee much confusion in the future.
+Tom Plum: suggest to break into several sentences
 
    
 
    
-Alan to write a non-normative comment to explain the use of fully-closed ranges.
+Walter: suggest "comma" before the "and" in both places
 
    
 
    
-Move to Ready, with the changes described above. (Howard: awaiting note from Alan)
+Recommend Review.
 
    
 
    
 
+
    [
+Batavia (2009-05):
+]
    
 
-
-
    Proposed resolution:
    
-
    
-Wording below assumes issue 878 is accepted, but this issue is
-independent of that issue.
+
    
+The post-Summit comments have been applied to the proposed resolution.
+We now agree with the proposed resolution.
+Move to Tentatively Ready.
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+Moved from Tentatively Ready to Open only because the wording needs to be
+improved for enable_if type constraining, possibly following Robert's
+formula.
+
    
+
+
    [
+2009-08-01 Howard updates wording and sets to Review.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change 20.8.14.2.1 [unique.ptr.single.ctor]:
+
    
+
+
    
+
    template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);
+
    
+
    
+
    
+-20- Requires: If D is not a reference type,
+construction of the deleter D from an rvalue of type E
+shall be well formed and shall not throw an exception. If D is
+a reference type, then E shall be the same type as D
+(diagnostic required). unique_ptr<U, E>::pointer shall be
+implicitly convertible to pointer. [Note: These requirements
+imply that T and U are complete types. — end note]
 
    
 
+
    
+Remarks: If D is
+a reference type, then E shall be the same type as D, else this
+constructor shall not participate in overload resolution. unique_ptr<U, E>::pointer shall be
+implicitly convertible to pointer, else this
+constructor shall not participate in overload resolution. U shall not be
+an array type, else this
+constructor shall not participate in overload resolution. [Note: These requirements
+imply that T and U are complete types. — end note]
+
    
+
+
    
+
    
+
 
    
-Change 23.3.3.4 [forwardlist.modifiers]:
+Change 20.8.14.2.3 [unique.ptr.single.asgn]:
 
    
 
 
    
-
    iterator erase_after(const_iterator position);
+
    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);
 
    
 
    
 
    
-Requires: The iterator following position is dereferenceable.
+-6- Requires: Assignment of the deleter D from an rvalue
+D shall not throw an exception. unique_ptr<U,
+E>::pointer shall be implicitly convertible to pointer.
+[Note: These requirements imply that T and U
+are complete types. — end note]
 
    
+
+
    
+Remarks: unique_ptr<U,
+E>::pointer shall be implicitly convertible to pointer, else this
+operator shall not participate in overload resolution.
+U shall not be an array type, else this
+operator shall not participate in overload resolution.
+[Note: These requirements imply that T and U
+are complete types. — end note]
+
    
+
+
    
+
    
+
+
+
+
+
+
+
    
+
    951. Various threading bugs #1
    
+
    Section: 20.9.2.1 [time.traits.is_fp] Status: Open
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-23
    
+
    View all issues with Open status.
    
+
    Discussion:
    
+
 
    
-Effects: Erases the element pointed to by the iterator following position.
+Related to 953.
 
    
+
 
    
-Returns: An iterator pointing to the element following the one that was erased, or end() if no such 
-element exists
-An iterator equal to position.
+20.9.2.1 [time.traits.is_fp] says that the type Rep "is
+assumed to be ... a class emulating an integral type." What are the
+requirements for such a type?
 
    
+
    [
+2009-05-10 Howard adds:
+]
    
+
+
+
    
+IntegralLike.
 
    
 
+
    [
+Batavia (2009-05):
+]
    
 
-
    iterator erase_after(const_iterator position, const_iterator last);
-
    
 
    
 
    
-Requires: All iterators in the range
-[(position,last)
-are dereferenceable.
+As with issue 953,
+we recommend this issue be addressed in the context of providing concepts for the entire thread header.
 
    
 
    
-Effects: Erases the elements in the range
-[(position,last).
+We look forward to proposed wording.
 
    
 
    
-Returns:  An iterator equal to position last
+Move to Open.
 
    
 
    
-
    
 
-
    
-Change 23.3.3.5 [forwardlist.ops]:
-
    
+
    [
+2009-08-01 Howard adds:
+]
    
+
 
-
    
-
    void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
-
    
 
    
 
    
-Requires: position is before_begin() or a
-dereferenceable iterator in the range [begin(), end)). &x != this.
+I have surveyed all clauses of 20.9.2.2 [time.traits.duration_values],
+20.9.2.3 [time.traits.specializations] and 20.9.3 [time.duration].
+I can not find any clause which involves the use of a duration::rep type
+where the requirements on the rep type are not clearly spelled out.
+These requirements were carefully crafted to allow any arithmetic type, or
+any user-defined type emulating an arithmetic type.
 
    
+
 
    
-Effects: Inserts the contents of x after position, and
-x becomes empty. Pointers and references to 
-the moved elements of x now refer to those same elements but as members of *this.
-Iterators referring to the moved elements will continue to refer to their elements,
-but they now behave as iterators into *this, not into x. 
+Indeed, treat_as_floating_point
+becomes completely superfluous if duration::rep can never be a class type.
 
    
+
 
    
-Throws: Nothing. 
+There will be some Rep types which will not meet the requirements of
+every duration operation.  This is no different than the fact
+that vector<T> can easily be used for types T which are
+not DefaultConstructible, even though some members of vector<T>
+require T to be DefaultConstructible.  This is why the requirements
+on Rep are specified for each operation individually.
 
    
+
 
    
-Complexity: Ο(1) Ο(distance(x.begin(), x.end()))
+In 20.9.2.1 [time.traits.is_fp] p1:
 
    
-
    
-
-
    ...
    
 
-
    void splice_after(const_iterator position, forward_list<T,Allocator>&& x, 
-                  const_iterator first, const_iterator last);
+
    template <class Rep> struct treat_as_floating_point 
+  : is_floating_point<Rep> { };
 
    
+
 
    
+The duration template uses the treat_as_floating_point trait to help
+determine if a duration object can be converted to another duration
+with a different tick period. If treat_as_floating_point<Rep>::value is
+true, then Rep is a floating-point type and implicit conversions are
+allowed among durations. Otherwise, the implicit convertibility depends
+on the tick periods of the durations. If Rep is a class type which
+emulates a floating-point type, the author of Rep can specialize
+treat_as_floating_point so that duration will treat this Rep as if it
+were a floating-point type. Otherwise Rep is assumed to be an integral
+type or a class emulating an integral type.
+
    
+
    
+
 
    
-Requires: position is before_begin() or a
-dereferenceable iterator in the range [begin(), end)).
-(first,last) is a valid range in
-x, and all iterators in the range
-(first,last) are dereferenceable.
-position is not an iterator in the range (first,last).
+The phrases "a class type which emulates a floating-point type" and
+"a class emulating an integral type" are clarifying phrases which refer to
+the summation of all the requirements on the Rep type specified in
+detail elsewhere (and should not be repeated here).
+
    
+
+
    
+This specification has been implemented, now multiple times, and the experience
+has been favorable.  The current specification clearly specifies the requirements
+at each point of use (though I'd be happy to fix any place I may have missed,
+but none has been pointed out).
 
    
+
 
    
-Effects: Inserts elements in the range (first,last)
-after position and removes the elements from x.
-Pointers and references to the moved elements of x now refer to
-those same elements but as members of *this. Iterators
-referring to the moved elements will continue to refer to their
-elements, but they now behave as iterators into *this, not into
-x.
+I am amenable to improved wording of this paragraph (and any others), but do not have any
+suggestions for improved wording at this time.  I am strongly opposed to
+changes which would significantly alter the semantics of the
+specification under 20.9 [time] without firmly grounded and
+documented rationale, example implementation, testing, and user
+experience which relates a positive experience.
 
    
+
 
    
-Complexity: Ο(1).
+I recommend NAD unless someone wants to produce some clarifying wording.
 
    
 
    
 
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Stefanus to provide wording to turn this into a note.
 
    
 
 
 
+
    Proposed resolution:
    
+
    
+
    
+
+
 
 
 
 
    
-
    900. stream move-assignment
    
-
    Section: 27.9.1.8 [ifstream.assign] Status: Open
- Submitter: Niels Dekker Opened: 2008-09-20  Last modified: 2009-07-26
    
+
    953. Various threading bugs #3
    
+
    Section: 20.9.1 [time.clock.req] Status: Open
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-23
    
+
    View other active issues in [time.clock.req].
    
+
    View all other issues in [time.clock.req].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
-
    
-It
-appears that we have an issue similar to issue 675 regarding the move-assignment of
-stream types. For example, when assigning to an std::ifstream,
-ifstream1, it seems preferable to close the file originally held by
-ifstream1:
-
    
-
-
    ifstream1 = std::move(ifstream2); 
-
    
 
 
    
-The current Draft
-(N2723)
-specifies that the move-assignment of
-stream types like ifstream has the same effect as a swap:
+Related to 951.
 
    
 
-
    
 
    
-Assign and swap 27.9.1.8 [ifstream.assign]
+20.9.1 [time.clock.req] says that a clock's rep member is "an
+arithmetic type or a class emulating an arithmetic type." What are the
+requirements for such a type?
 
    
-
    basic_ifstream& operator=(basic_ifstream&& rhs); 
-
    
+
+
    [
+2009-05-10 Howard adds:
+]
    
+
+
 
    
-Effects: swap(rhs).
-
    
+This wording was aimed directly at the ArithmeticLike concept.
 
    
 
 
    [
@@ -15651,374 +13069,407 @@ Batavia (2009-05):
 
 
    
 
    
-Howard agrees with the analysis and the direction proposed.
+We recommend this issue be addressed in the context of providing concepts
+for the entire thread header.
 
    
 
    
-Move to Open pending specific wording to be supplied by Howard.
+May resolve for now by specifying arithmetic types,
+and in future change to ArithmeticLike.
+However, Alisdair believes this is not feasible.
+
    
+
    
+Bill disagrees.
+
    
+
    
+We look forward to proposed wording.  Move to Open.
 
    
 
    
 
 
    [
-2009-07 Frankfurt:
+2009-08-01 Howard adds:
 ]
    
 
 
 
    
-Howard is going to write wording.
+See commented dated 2009-08-01 in 951.
 
    
 
 
    [
-2009-07-26 Howard provided wording.
+2009-10 Santa Cruz:
 ]
    
 
 
+
    
+Stefanus to provide wording to turn this into a note.
+
    
 
 
-
    Proposed resolution:
    
 
+
    Proposed resolution:
    
 
    
-Change 27.8.1.2 [stringbuf.assign]/1:
 
    
 
-
    basic_stringbuf& operator=(basic_stringbuf&& rhs);
-
    
-
    
--1- Effects: swap(rhs).
-After the move assignment *this reflects the same observable
-state it would have if it had been move constructed from rhs
-(27.8.1.1 [stringbuf.cons]).
-
-
    
-
    
 
-
    
-Change 27.8.2.2 [istringstream.assign]/1:
-
    
 
-
    basic_istringstream& operator=(basic_istringstream&& rhs);
-
    
-
    
--1- Effects: swap(rhs).
-Move assigns the base and members of *this with the respective
-base and members of rhs.
-
-
    
-
    
 
+
+
    
+
    954. Various threading bugs #4
    
+
    Section: 20.9.1 [time.clock.req] Status: Ready
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-21
    
+
    View other active issues in [time.clock.req].
    
+
    View all other issues in [time.clock.req].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-Change 27.8.3.2 [ostringstream.assign]/1:
+Table 55 -- Clock Requirements (in 20.9.1 [time.clock.req])
 
    
 
-
    basic_ostringstream& operator=(basic_ostringstream&& rhs);
-
    
-
    
--1- Effects: swap(rhs).
-Move assigns the base and members of *this with the respective
-base and members of rhs.
-
-
    
-
    
+
      
+
    1. 
+the requirements for C1::time_point require C1 and C2
+to "refer to the same epoch", but "epoch" is not defined.
+
      2. 
+
    2. 
+"Different clocks may share a time_point definition if it is
+valid to compare their time_points by comparing their
+respective durations." What does "valid" mean here? And, since
+C1::rep is "**THE** representation type of the native
+duration and time_point" (emphasis added), there
+doesn't seem to be much room for some other representation.
+
      3. 
+
    3. 
+C1::is_monotonic has type "const bool". The
+"const" should be removed.
+
      4. 
+
    4. 
+C1::period has type ratio. ratio isn't a type, 
+it's a template. What is the required type?
+
      5. 
+
    
 
-
    
-Change 27.8.5.1 [stringstream.assign]/1:
-
    
+
    [
+2009-05-10 Howard adds:
+]
    
 
-
    basic_stringstream& operator=(basic_stringstream&& rhs);
-
    
-
    
--1- Effects: swap(rhs).
-Move assigns the base and members of *this with the respective
-base and members of rhs.
-
-
    
-
    
 
+
      
+
    1. 
 
      
-Change 27.9.1.3 [filebuf.assign]/1:
+"epoch" is purposefully not defined beyond the common English
+definition.  The C standard
+also chose not to define epoch, though POSIX did.  I believe it is a strength
+of the C standard that epoch is not defined.  When it is known that two time_points
+refer to the same epoch, then a definition of the epoch is not needed to compare
+the two time_points, or subtract them.
 
      
-
-
      basic_filebuf& operator=(basic_filebuf&& rhs);
-
      
-
      
--1- Effects: swap(rhs).
-Begins by calling this->close().
-After the move assignment *this reflects the same observable
-state it would have if it had been move constructed from rhs
-(27.9.1.2 [filebuf.cons]).
-
-
      
-
      
-
 
      
-Change 27.9.1.8 [ifstream.assign]/1:
+A time_point and a Clock implicitly refer to an (unspecified) epoch.
+The time_point represents an offset (duration) from an epoch.
+
      
+
      2. 
+
    2. 
+
      
+The sentence:
 
      
-
-
      basic_ifstream& operator=(basic_ifstream&& rhs);
-
      
 
      
--1- Effects: swap(rhs).
-Move assigns the base and members of *this with the respective
-base and members of rhs.
-
      
+Different clocks 
+may share a time_point
+definition if it is valid to 
+compare their time_points by 
+comparing their respective 
+durations.
 
      
 
 
      
-Change 27.9.1.12 [ofstream.assign]/1:
+is redundant and could be removed.  I believe the sentence which follows the above:
 
      
 
-
      basic_ofstream& operator=(basic_ofstream&& rhs);
-
      
 
      
--1- Effects: swap(rhs).
-Move assigns the base and members of *this with the respective
-base and members of rhs.
-
      
+C1 and C2 shall refer to the same epoch.
 
      
 
 
      
-Change 27.9.1.16 [fstream.assign]/1:
+is sufficient.  If two clocks share the same epoch, then by definition, comparing
+their time_points is valid.
+
      
+
      3. 
+
    3. 
+is_monotonic is meant to never change (be const).  It is also
+desired that this value be usable in compile-time computation and branching.
+
      4. 
+
    4. 
+
      
+This should probably instead be worded:
 
      
-
-
      basic_fstream& operator=(basic_fstream&& rhs);
-
      
 
      
--1- Effects: swap(rhs).
-Move assigns the base and members of *this with the respective
-base and members of rhs.
-
      
+An instantiation of ratio.
 
      
+
      5. 
+
    
 
+
    [
+Batavia (2009-05):
+]
    
 
+
    
+
    
+Re (a): It is not clear to us whether "epoch" is a term of art.
+
    
+
    
+Re (b), (c), and (d):  We agree with Howard's comments,
+and would consider adding to (c) a static constexpr requirement.
+
    
+
    
+Move to Open pending proposed wording.
+
    
+
    
 
+
    [
+2009-05-25 Daniel adds:
+]
    
 
 
+
    
+In regards to (d) I suggest to say "a specialization of ratio" instead of
+"An instantiation of ratio". This seems to be the better matching standard
+core language term for this kind of entity.
+
    
 
-
    
-
    908. Deleted assignment operators for atomic types must be volatile
    
-
    Section: 29.5 [atomics.types] Status: Open
- Submitter: Anthony Williams Opened: 2008-09-26  Last modified: 2009-03-22
    
-
    View all other issues in [atomics.types].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    [
+2009-05-25 Ganesh adds:
+]
    
 
-
    Addresses US 90
    
 
+
    
 
    
-The deleted copy-assignment operators for the atomic types are not
-marked as volatile in N2723, whereas the assignment operators from the
-associated non-atomic types are. e.g.
+Regarding (a), I found this paper on the ISO website using the term "epoch" consistently with the current wording:
 
    
-
    atomic_bool& operator=(atomic_bool const&) = delete;
-atomic_bool& operator=(bool) volatile;
-
    
 
 
    
-This leads to ambiguity when assigning a non-atomic value to a
-non-volatile instance of an atomic type:
+http://standards.iso.org/ittf/PubliclyAvailableStandards/C030811e_FILES/MAIN_C030811e/text/ISOIEC_18026E_TEMPORAL_CS.HTM
 
    
-
    atomic_bool b;
-b=false;
-
    
-
 
    
-Both assignment operators require a standard conversions: the
-copy-assignment operator can use the implicit atomic_bool(bool)
-conversion constructor to convert false to an instance of
-atomic_bool, or b can undergo a qualification conversion in order to
-use the assignment from a plain bool.
+which is part of ISO/IEC 18026 "Information technology -- Spatial Reference Model (SRM)".
 
    
+
    
+
+
    [
+2009-08-01 Howard: Moved to Reivew as the wording requested in Batavia has been provided.
+]
    
 
-
    
-This is only a problem once issue 845 is applied.
-
    
 
 
    [
-Summit:
+2009-10 Santa Cruz:
 ]
    
 
+
 
    
-Move to open. Assign to Lawrence. Related to US 90 comment.
+Move to Ready.
 
    
 
 
+
 
    Proposed resolution:
    
+
      
+
    1. 
 
      
-Add volatile qualification to the deleted copy-assignment operator of
-all the atomic types:
+Change 20.9.1 [time.clock.req] p1:
 
      
-
-
      atomic_bool& operator=(atomic_bool const&) volatile = delete;
-atomic_itype& operator=(atomic_itype const&) volatile = delete;
-
      
-
+
      
+-1- A clock is a bundle consisting of a native duration, a native time_point, and a function now() to get the 
+current time_point.  The origin of the clock's time_point is referred to as the clock's epoch as defined in 
+section 6.3 of ISO/IEC 18026.
+A clock shall meet the requirements in Table 45.
+
      
+
      2. 
+
    2. 
 
      
-etc.
+Remove the sentence from the time_point row of the table "Clock Requirements":
 
      
+
+
+
+
+
+
+
+
      Clock requirements
      
+C1::time_point
+
+chrono::time_point<C1> or chrono::time_point<C2, C1::duration>
+
+The native time_point type of the clock.
+Different clocks may share a time_point definition if it is valid to compare their time_points by comparing their respective durations.
+C1 and C2 shall refer to the same epoch.
+
      
+
      3. 
+
    
+
      
+
    1. 
 
      
-This will mean that the deleted copy-assignment operator will require
-two conversions in the above example, and thus be a worse match than
-the assignment from plain bool.
+Change the row starting with C1::period of the table "Clock Requirements":
 
      
+
+
+
+
+
+
+
+
      Clock requirements
      
+C1::period
+
+a specialization of ratio
+
+The tick period of the clock in seconds.
+
      
+
+
      2. 
+
    
 
 
 
 
 
 
    
-
    910. Effects of MoveAssignable
    
-
    Section: 20.2.9 [concept.copymove] Status: Open
- Submitter: Alberto Ganesh Barbati Opened: 2008-09-29  Last modified: 2009-07-18
    
+
    956. Various threading bugs #6
    
+
    Section: 20.9.1 [time.clock.req] Status: Open
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-24
    
+
    View other active issues in [time.clock.req].
    
+
    View all other issues in [time.clock.req].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
-
    Addresses UK 150
    
-
 
    
-The description of the effect of operator= in the MoveAssignable
-concept, given in paragraph 7 is:
+20.9.1 [time.clock.req] uses the word "native" in several places,
+but doesn't define it. What is a "native duration"?
 
    
 
-
    result_type  T::operator=(T&&  rv);  // inherited from HasAssign<T, T&&>
-
    
+
    [
+2009-05-10 Howard adds:
+]
    
+
 
 
    
-Postconditions: the constructed T object is equivalent to the value of
-rv before the assignment. [Note: there is no
-requirement on the value of rv after the assignment.  --end note]
-
    
+The standard uses "native" in several places without defining it (e.g.
+2.14.3 [lex.ccon]).  It is meant to mean "that which is defined
+by the facility", or something along those lines.  In this case it refers
+to the nested time_point and duration types of the clock.
+Better wording is welcome.
 
    
 
-
    
-The sentence contains a typo (what is the "constructed T object"?)
-probably due to a cut&paste from MoveConstructible. Moreover, the
-discussion of LWG issue 675 shows that the postcondition is too generic
-and might not reflect the user expectations. An implementation of the
-move assignment that just calls swap() would always fulfill the
-postcondition as stated, but might have surprising side-effects in case
-the source rvalue refers to an object that is not going to be
-immediately destroyed. See LWG issue 900 for another example. Due to
-the sometimes intangible nature of the "user expectation", it seems
-difficult to have precise normative wording that could cover all cases
-without introducing unnecessary restrictions. However a non-normative
-clarification could be a very helpful warning sign that swapping is not
-always the correct thing to do.
-
    
-
 
    [
-2009-05-09 Alisdair adds:
+Batavia (2009-05):
 ]
    
 
-
 
    
-
    
-Issue 910 is exactly the reason BSI advanced the Editorial comment UK-150.
-
    
-
    
-The post-conditions after assignment are at a minimum that the object
-referenced by rv must be safely destructible, and the transaction should not
-leak resources.  Ideally it should be possible to simply assign rv a new
-valid state after the call without invoking undefined behaviour, but any
-other use of the referenced object would depend upon additional guarantees
-made by that type.
-
    
+Move to Open pending proposed wording from Pete.
 
    
 
 
    [
-2009-05-09 Howard adds:
+2009-10-23 Pete provides wording:
 ]
    
 
 
-
    
-
    
-The intent of the rvalue reference work is that the moved from rv is
-a valid object.  Not one in a singular state.  If, for example, the moved from
-object is a vector, one should be able to do anything on that moved-from
-vector that you can do with any other vector.  However you would
-first have to query it to find out what its current state is.  E.g. it might have capacity,
-it might not.  It might have a non-zero size, it might not.  But regardless,
-you can push_back on to it if you want.
-
    
 
+
    Proposed resolution:
    
 
    
-That being said, most standard code is now conceptized.  That is, the concepts
-list the only operations that can be done with templated types - whether or not
-the values have been moved from.
+Remove every occurrence of "native" in 20.9.1 [time.clock.req].
 
    
 
 
    
-Here is user-written code which must be allowed to be legal:
+Add the following sentence at the end of 20.9.1 [time.clock.req]/1:
 
    
-
    #include <vector>
-#include <cstdio>
 
-template <class Allocator>
-void
-inspect(std::vector<double, Allocator>&& v)
-{
-    std::vector<double, Allocator> result(move(v));
-    std::printf("moved from vector has %u size and %u capacity\n", v.size(), v.capacity());
-    std::printf("The contents of the vector are:\n");
-    typedef typename std::vector<double, Allocator>::iterator I;
-    for (I i = v.begin(), e = v.end(); i != e; ++i)
-        printf("%f\n", *i);
-}
+
    
+A clock is a bundle consisting of a native duration, a native
+time_point, and a function now() to get the current time_point. A clock
+shall meet the requirements in Table 55.
+The duration and time_point types have the natural size and resolution
+suggested by the architecture of the execution environment.
+
    
 
-int main()
-{
-    std::vector<double> v1(100, 5.5);
-    inspect(move(v1));
-}
-
    
 
+
+
+
+
    
+
    957. Various threading bugs #7
    
+
    Section: 20.9.5.1 [time.clock.system] Status: Ready
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-21
    
+
    View all other issues in [time.clock.system].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-The above program does not treat the moved-from vector as singular.  It
-only treats it as a vector with an unknown value.
-
    
-
    
-I believe the current proposed wording is consistent with my view on this.
+20.9.5.1 [time.clock.system]: to_time_t is overspecified. It
+requires truncation, but should allow rounding. For example, suppose a
+system has a clock that gives times in milliseconds, but time() rounds
+those times to the nearest second. Then system_clock can't use any
+resolution finer than one second, because if it did, truncating times
+between half a second and a full second would produce the wrong time_t
+value.
 
    
-
    
+
+
    [
+Post Summit Anthony Williams provided proposed wording.
+]
    
+
 
 
    [
 Batavia (2009-05):
 ]
    
 
 
    
-We agree that the proposed resolution
-is an improvement over the current wording.
+Move to Review pending input from Howard. and other stakeholders.
 
    
 
 
    [
-2009-07 Frankfurt:
+2009-05-23 Howard adds:
 ]
    
 
 
 
    
-Need to look at again without concepts.
+I am in favor of the wording provided by Anthony.
 
    
 
 
    [
-2009-07 Frankfurt:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-Walter will consult with Dave and Doug.
+Move to Ready.
 
    
 
 
 
 
    Proposed resolution:
    
 
    
-In 20.2.9 [concept.copymove], replace the postcondition in paragraph 7 with:
+In 20.9.5.1 [time.clock.system] replace paragraphs 3 and 4 with:
 
    
 
 
    
-Postconditions: *this is equivalent to the value of rv before the
-assignment. [Note: there is no requirement on the value of rv after the
-assignment, but the
-effect should be unsurprising to the user even in case rv is not
-immediately destroyed. This may require that resources previously owned
-by *this are released instead of transferred to rv. -- end note]
+
    time_t to_time_t(const time_point& t);
+
    
+
    
+-3- Returns: A time_t object that represents the same
+point in time as t when both values are truncated
+restricted to the coarser of the precisions of
+time_t and time_point.  It is implementation
+defined whether values are rounded or truncated to the required
+precision.
+
    
+
+
    time_point from_time_t(time_t t);
+
    
+
    
+-4- Returns: A time_point object that represents the
+same point in time as t when both values are truncated
+restricted to the
+coarser of the precisions of time_t and time_point.
+It is implementation defined whether values are
+rounded or truncated to the required precision.
+
    
 
    
 
 
@@ -16026,351 +13477,345 @@ by *this are released instead of transferred to rv. -- end
 
 
 
    
-
    911. I/O streams and move/swap semantic
    
-
    Section: 27.7.1 [input.streams], 27.7.2 [output.streams] Status: Open
- Submitter: Alberto Ganesh Barbati Opened: 2008-09-29  Last modified: 2009-07-27
    
+
    959. Various threading bugs #9
    
+
    Section: 30.5.1 [thread.condition.condvar] Status: Open
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-26
    
+
    View other active issues in [thread.condition.condvar].
    
+
    View all other issues in [thread.condition.condvar].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
 
    
-Class template basic_istream, basic_ostream and basic_iostream
-implements public move constructors, move assignment operators and swap
-method and free functions. This might induce both the user and the
-compiler to think that those types are MoveConstructible, MoveAssignable
-and Swappable. However, those class templates fail to fulfill the user
-expectations. For example:
+30.5.1 [thread.condition.condvar]: condition_variable::wait_for
+is required to compute the absolute time by adding the duration value to
+chrono::monotonic_clock::now(), but monotonic_clock is not required to
+exist.
 
    
 
-
    std::ostream os(std::ofstream("file.txt"));
-assert(os.rdbuf() == 0); // buffer object is not moved to os, file.txt has been closed
+
    [
+Summit:
+]
    
 
-std::vector<std::ostream> v;
-v.push_back(std::ofstream("file.txt"));
-v.reserve(100); // causes reallocation
-assert(v[0].rdbuf() == 0); // file.txt has been closed!
 
-std::ostream&& os1 = std::ofstream("file1.txt");
-os1 = std::ofstream("file2.txt");
-os1 << "hello, world"; // still writes to file1.txt, not to file2.txt!
+
    
+Move to open. Associate with LWG 859 and any other monotonic-clock
+related issues.
+
    
 
-std::ostream&& os1 = std::ofstream("file1.txt");
-std::ostream&& os2 = std::ofstream("file2.txt");
-std::swap(os1, os2);
-os1 << "hello, world"; // writes to file1.txt, not to file2.txt!
-
    
+
    [
+2009-08-01 Howard adds:
+]
    
 
-
    
-This is because the move constructor, the move assignment operator and
-swap are all implemented through calls to std::basic_ios member
-functions move() and swap() that do not move nor swap the controlled
-stream buffers. That can't happen because the stream buffers may have
-different types.
-
    
 
-
    
-Notice that for basic_streambuf, the member function swap() is
-protected. I believe that is correct and all of basic_istream,
-basic_ostream, basic_iostream should do the same as the move ctor, move
-assignment operator and swap member function are needed by the derived
-fstreams and stringstreams template. The free swap functions for
-basic_(i|o|io)stream templates should be removed for the same reason.
-
    
+
    
+I believe that 859 (currently Ready) addresses this issue, and
+that this issue should be marked NAD, solved by 859 (assuming
+it moves to WP).
+
    
 
 
    [
-Batavia (2009-05):
+2009-10 Santa Cruz:
 ]
    
 
+
 
    
+Leave open, but expect to be fixed by N2969 revision that Detlef is writing.
+
    
+
+
+
+
    Proposed resolution:
    
 
    
-We note that the rvalue swap functions have already been removed.
-
    
-
    
-Bill is unsure about making the affected functions protected;
-he believes they may need to be public.
-
    
-
    
-We are also unsure about removing the lvalue swap functions as proposed.
 
    
+
+
+
+
+
+
    
+
    960. Various threading bugs #10
    
+
    Section: 30.4.1 [thread.mutex.requirements] Status: Ready
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-26
    
+
    View other active issues in [thread.mutex.requirements].
    
+
    View all other issues in [thread.mutex.requirements].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-Move to Open.
+30.4.1 [thread.mutex.requirements]: paragraph 4 is entitled
+"Error conditions", but according to 17.5.1.4 [structure.specifications], "Error
+conditions:" specifies "the error conditions for error codes reported by
+the function." It's not clear what this should mean when there is no
+function in sight.
 
    
-
    
 
 
    [
-2009-07 Frankfurt:
+Summit:
 ]
    
 
 
 
    
-
    
-It's not clear that the use case is compelling.
-
    
-
    
-Howard: This needs to be implemented and tested.
-
    
+Move to open.
 
    
 
 
    [
-2009-07-26 Howard adds:
+Beman provided proposed wording.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
+Move to Ready. Fix the proposed wording with "functions of type Mutex"
+-> "functions of Mutex type"
+
    
+
+
+
+
    Proposed resolution:
    
 
    
-I started out thinking I would recommend NAD for this one.  I've turned around
-to agree with the proposed resolution (which I've updated to the current draft).
-I did not fully understand Ganesh's rationale, and attempt to describe my
-improved understanding below.
+Change 30.4.1 [thread.mutex.requirements] Mutex requirements,
+paragraph 4 as indicated:
 
    
 
+
    
 
    
-The move constructor, move assignment operator, and swap function are different
-for basic_istream, basic_ostream and basic_iostream
-than other classes.  A timely conversation with Daniel reminded me of this long
-forgotten fact.  These members are sufficiently different that they would be
-extremely confusing to use in general, but they are very much needed for derived
-clients.
+-4- Error conditions:
+The error conditions for error codes, if any, reported by member
+functions of Mutex type shall be:
 
    
-
 
      
 
    • 
-The move constructor moves everything but the rdbuf pointer.
+not_enough_memory -- if there is not enough memory to construct
+the mutex object.
 
      • 
 
    • 
-The move assignment operator moves everything but the rdbuf pointer.
+resource_unavailable_try_again -- if any native handle type
+manipulated is not available.
 
      • 
 
    • 
-The swap function swaps everything but the rdbuf pointer.
+operation_not_permitted -- if the thread does not have the
+necessary permission to change the state of the mutex object.
+
      • 
+
    • 
+device_or_resource_busy -- if any native handle type
+manipulated is already locked.
+
      • 
+
    • 
+invalid_argument -- if any native handle type manipulated as
+part of mutex construction is incorrect.
 
      • 
 
    
-
-
    
-The reason for this behavior is that for the std-derived classes (stringstreams,
-filestreams), the rdbuf pointer points back into the class itself
-(self referencing).  It can't be swapped or moved.  But this fact isn't born out
-at the stream level.  Rather it is born out at the fstream/sstream
-level.  And the lower levels just need to deal with that fact by not messing around
-with the rdbuf pointer which is stored down at the lower levels.
-
    
-
-
    
-In a nutshell, it is very confusing for all of those who are not so intimately
-related with streams that they've implemented them.  And it is even fairly
-confusing for some of those who have (including myself).  I do not think it is
-safe to swap or move istreams or ostreams because this will
-(by necessary design) separate stream state from streambuffer state.  Derived
-classes (such as fstream and stringstream must be used to
-keep the stream state and stream buffer consistently packaged as one unit during
-a move or swap.
-
    
-
-
    
-I've implemented this proposal and am living with it day to day.
-
    
-
 
    
 
 
 
-
    Proposed resolution:
    
-
    
-27.7.1.1 [istream]: make the following member functions protected:
-
    
 
-
    basic_istream(basic_istream&&  rhs);
-basic_istream&  operator=(basic_istream&&  rhs);
-void  swap(basic_istream&  rhs);
-
    
 
+
    
+
    962. Various threading bugs #12
    
+
    Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: Ready
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-22
    
+
    View other active issues in [thread.lock.unique.locking].
    
+
    View all other issues in [thread.lock.unique.locking].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-Ditto: remove the swap free function signature
+30.4.3.2.2 [thread.lock.unique.locking]:  unique_lock::lock is
+required to throw an object of type std::system_error "when the
+postcondition cannot be achieved." The postcondition is owns == true,
+and this is trivial to achieve. Presumably, the requirement is intended
+to mean something more than that.
 
    
 
-
    // swap: 
-template <class charT, class traits> 
-  void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);
-
    
-
-
    
-27.7.1.1.2 [istream.assign]: remove paragraph 4
-
    
+
    [
+Summit:
+]
    
 
-
    template <class charT, class traits> 
-  void swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);
-
    
 
    
-Effects: x.swap(y).
-
    
+Move to open.
 
    
 
-
    
-27.7.1.5 [iostreamclass]: make the following member function protected:
-
    
+
    [
+Beman has volunteered to provide proposed wording.
+]
    
 
-
    basic_iostream(basic_iostream&&  rhs);
-basic_iostream&  operator=(basic_iostream&&  rhs);
-void  swap(basic_iostream&  rhs);
-
    
 
-
    
-Ditto: remove the swap free function signature
-
    
+
    [
+2009-07-21 Beman added wording to address 30.2.2 [thread.req.exception]
+in response to the Frankfurt notes in 859.
+]
    
 
-
    template <class charT, class traits> 
-  void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);
-
    
 
-
    
-27.7.1.5.3 [iostream.assign]: remove paragraph 3
-
    
+
    [
+2009-09-25 Beman: minor update to wording.
+]
    
 
-
    template <class charT, class traits> 
-  void swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);
-
    
-
    
-Effects: x.swap(y).
-
    
-
    
 
-
    
-27.7.2.1 [ostream]: make the following member function protected:
-
    
+
    [
+2009-10 Santa Cruz:
+]
    
 
-
    basic_ostream(basic_ostream&&  rhs);
-basic_ostream&  operator=(basic_ostream&&  rhs);
-void  swap(basic_ostream&  rhs);
-
    
 
-
    
-Ditto: remove the swap free function signature
-
    
+
    
+Move to Ready.
+
    
 
-
    // swap: 
-template <class charT, class traits> 
-  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
-
    
 
-
    
-27.7.2.3 [ostream.assign]: remove paragraph 4 
-
    
 
-
    template <class charT, class traits> 
-  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
-
    
+
    Proposed resolution:
    
+
+
    Change Exceptions 30.2.2 [thread.req.exception] as indicated:
    
 
    
-Effects: x.swap(y).
-
    
+
    Some functions described in this Clause are specified to throw exceptions of 
+type system_error (19.5.5). Such exceptions shall be thrown if 
+any of the Error conditions are detected or a call to an operating 
+system or other underlying API results in an error that prevents the library 
+function from satisfying its postconditions or from returning a meaningful 
+value meeting its specifications. Failure to
+allocate storage shall be reported as described in
+17.6.4.11 [res.on.exception.handling].
    
 
    
 
+
    Change thread assignment 30.3.1.5 [thread.thread.member], join(), 
+paragraph 8 as indicated:
    
+
    
+
    Throws: std::system_error when the postconditions cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
 
+
    
 
+
    Change thread assignment 30.3.1.5 [thread.thread.member], detach(), paragraph 
+13 as indicated:
    
+
    
 
+
    Throws: std::system_error when the effects or 
+postconditions cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
 
+
    
 
-
    
-
    915. minmax with initializer_list should return
-pair of T, not pair of const T&
    
-
    Section: 25.5.7 [alg.min.max] Status: Open
- Submitter: Daniel Krügler Opened: 2008-10-04  Last modified: 2009-07-14
    
-
    View all other issues in [alg.min.max].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-It seems that the proposed changes for
-N2772
-were not clear enough in
-this point:
-
    
+
    Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph 
+11, as indicated:
    
+
    
 
+
    Throws: std::system_error when the effects or 
+postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
+
    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], 
+paragraph 3, as indicated:
    
 
    
-25.5.7 [alg.min.max], before p.23 + p.24 + before p. 27 + p. 28 say that the return
-type of the minmax overloads with an initializer_list is
-pair<const T&, const T&>,
-which is inconsistent with the decision for the other min/max overloads which take
-a initializer_list as argument and return a T, not a const T&.
-Doing otherwise for minmax would easily lead to unexpected life-time
-problems by using minmax instead of min and max separately.
+
+
    Throws: std::system_error when the  postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
 
    
+
    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], 
+paragraph 8, as indicated:
    
+
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    Throws: std::system_error when the  postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
+
    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], 
+paragraph 13, as indicated:
    
+
    
 
+
    Throws: std::system_error when the  postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
+
    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], 
+paragraph 18, as indicated:
    
 
    
-We agree with the proposed resolution.
-Move to Tentatively Ready.
+
+
    Throws: std::system_error when the  postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
 
    
+
    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], 
+paragraph 22, as indicated:
    
+
    
 
-
    [
-2009-07 Frankfurt
-]
    
+
    Throws: std::system_error when the  postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
+
    Change Function call_once 30.4.5.2 [thread.once.callonce], paragraph 4, as 
+indicated
    
+
    
+  
    Throws: std::system_error when the effects cannot be achieved an exception is required (30.2.2 [thread.req.exception]), 
+  or any exception thrown by func.
    
+
    
+
    Change Class condition_variable 30.5.1 [thread.condition.condvar], 
+paragraph 12, as indicated:
    
+
    
 
+
    Throws: std::system_error when the effects or 
+postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
+
    Change Class condition_variable 30.5.1 [thread.condition.condvar], 
+paragraph 19, as indicated:
    
+
    
 
+
    Throws: std::system_error when the effects or 
+postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
+
    Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], 
+paragraph 10, as indicated:
    
 
    
-Moved from Tentatively Ready to Open only because the wording needs to be
-tweaked for concepts removal.
+
+
    Throws: std::system_error when the effects or 
+postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
 
    
+
    Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], 
+paragraph 16, as indicated:
    
+
    
 
+
    Throws: std::system_error when the returned value, effects, or 
+postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).
    
+
    
 
+
    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been 
+applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as 
+indicated:
    
+
    
+
    template <class Rep, class Period> 
+bool wait_for(unique_lock<mutex>& lock, 
+              const chrono::duration<Rep, Period>& rel_time);
    
+
    ...
    
 
-
    Proposed resolution:
    
-
      
-
    1. 
-
      
-In 25 [algorithms]/2, header <algorithm> synopsis change as indicated:
-
      
-
-
      template<classLessThanComparable T>
-requires CopyConstructible<T>
-pair<const T&, const T&>
-minmax(initializer_list<T> t);
+
      Throws: std::system_error when the effects or 
+postcondition cannot be achieved an exception is required ([thread.req.exception]).
      
+
      
 
-template<class T, classStrictWeakOrder<auto, T> Compare>
-requires CopyConstructible<T>
-pair<const T&, const T&>
-minmax(initializer_list<T> t, Compare comp);
-
    - -
  • -

    -In 25.5.7 [alg.min.max] change as indicated (Begin: Just before p.20): -

    -
    template<classLessThanComparable T>
-  requires CopyConstructible<T>
-  pair<const T&, const T&>
-  minmax(initializer_list<T> t);
-
    +

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been +applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as +indicated:

    -

    --20- Requires: T is LessThanComparable and -CopyConstructible. -

    -

    --21- Returns: pair<const T&, const -T&>(x, y) where x is the -smallest value and y the largest value in the initializer_list. -

    -
    +
    template <class Rep, class Period, class Predicate> 
+  bool wait_for(unique_lock<mutex>& lock, 
+                const chrono::duration<Rep, Period>& rel_time, 
+                Predicate pred);
    + 
    ...
    -

    [..]

    -
    template<class T, classStrictWeakOrder<auto, T> Compare>
-  requires CopyConstructible<T>
-  pair<const T&, const T&>
-  minmax(initializer_list<T> t, Compare comp);
-
    +

    Throws: std::system_error when the effects or +postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    +
    +

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been +applied to the working paper, change 30.5.2 [thread.condition.condvarany] as +indicated:

    -

    --24- Requires: type T is LessThanComparable and CopyConstructible. -

    -

    --25- Returns: pair<const T&, const -T&>(x, y) where x is the -smallest value and y largest value in the initializer_list. -

    +
    template <class Lock, class Rep, class Period> 
+  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
    + 
    ...
    + +

    Throws: std::system_error when the returned value, effects or +postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    + +

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been +applied to the working paper, change 30.5.2 [thread.condition.condvarany] as +indicated:

    +
    +
    template <class Lock, class Rep, class Period, class Predicate> 
+  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
    + 
    ...
    + +

    Throws: std::system_error when the returned value, effects or +postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    • - @@ -16378,968 +13823,639 @@ smallest value and y largest value in the initializer_list.
    -

    916. Redundant move-assignment operator of pair should be removed

    -

    Section: 20.3.3 [pairs] Status: Open - Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-07-18

    -

    View other active issues in [pairs].

    -

    View all other issues in [pairs].

    -

    View all issues with Open status.

    +

    963. Various threading bugs #13

    +

    Section: 30.3.1.5 [thread.thread.member] Status: Ready + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

    +

    View other active issues in [thread.thread.member].

    +

    View all other issues in [thread.thread.member].

    +

    View all issues with Ready status.

    Discussion:

    -

    see also 917.

    - -

    -The current WP provides the following assignment operators for pair -in 20.3.3 [pairs]/1: -

    - -
      -
    1. -
      template<class U , class V>
-requires HasAssign<T1, const U&> && HasAssign<T2, const V&>
-pair& operator=(const pair<U , V>& p);
-
      -
      2. -
    2. -
      requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
-
      -
      3. -
    3. -
      template<class U , class V>
-requires HasAssign<T1, RvalueOf<U>::type> && HasAssign<T2, RvalueOf<V>::type>
-pair& operator=(pair<U , V>&& p);
-
      -
      4. -
    -

    -It seems that the functionality of (2) is completely covered by (3), therefore -(2) should be removed. +30.3.1.5 [thread.thread.member]: thread::detach is required to +throw an exception if the thread is "not a detachable thread". +"Detachable" is never defined.

    [ -Batavia (2009-05): +Howard adds: ]

    +
    -

    -Bill believes the extra assignment operators are necessary for resolving -ambiguities, but that does not mean it needs to be part of the specification. -

    -

    -Move to Open. -We recommend this be looked at in the context of the ongoing work -related to the pair templates. -

    +Due to a mistake on my part, 3 proposed resolutions appeared at approximately +the same time. They are all three noted below in the discussion.

    [ -2009-07 Frankfurt: +Summit, proposed resolution: ]

    -Leave this open pending the removal of concepts from the WD. -
    - - - -

    Proposed resolution:

    -
      -

    1. -In 20.3.3 [pairs] p. 1, class pair and just before p. 13 remove the declaration: +In 30.3.1.5 [thread.thread.member] change:

      -
      requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
-
      -
      2. - -
    2. -Remove p.13+p.14 -
      3. - -
    +
    void detach();
+
    +
    +

    ...

    +

    -14- Error conditions:

    +
      +
    • no_such_process -- if the thread is not a valid thread.
      • +
    • invalid_argument -- if the thread is not a detachable joinable thread.
      • +
    +
    +
    +
    +

    [ +Post Summit, Jonathan Wakely adds: +]

    -
    -

    917. Redundant move-assignment operator of tuple should be removed

    -

    Section: 20.5.2.1 [tuple.cnstr] Status: Open - Submitter: Daniel Krügler Opened: 2008-10-04 Last modified: 2009-07-18

    -

    View other active issues in [tuple.cnstr].

    -

    View all other issues in [tuple.cnstr].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    see also 916.

    +
    +

    +A thread is detachable if it is joinable. As we've defined joinable, +we can just use that. +

    +

    +This corresponds to the pthreads specification, where pthread_detach +fails if the thread is not joinable: +

    +
    +EINVAL: The implementation has detected that the value specified by +thread does not refer to a joinable thread. +
    +

    +Jonathan recommends this proposed wording: +

    +

    -N2770 (and thus now the WP) removed the -non-template move-assignment operator from tuple's class definition, -but the latter individual member description does still provide this -operator. Is this (a) an oversight and can it (b) be solved as part of an -editorial process? +In 30.3.1.5 [thread.thread.member] change:

    -

    [ -Post Summit Daniel provided wording. -]

    +
    void detach();
+
    +
    +

    ...

    +

    -14- Error conditions:

    +
      +
    • ...
      • +
    • invalid_argument -- not a detachable joinable thread.
      • +
    +
    +
    +
    +

    [ -Batavia (2009-05): +Post Summit, Anthony Williams adds: ]

    +

    -We believe that the proposed resolution's part 1 is editorial. -

    -

    -Regarding part 2, we either remove the specification as proposed, -or else add back the declaration to which the specification refers. -Alisdair and Bill prefer the latter. -It is not immediately obvious whether the function is intended to be present. +This is covered by the precondition that joinable() be true.

    -We recommend that the Project Editor restore the missing declaration -and that we keep part 2 of the issue alive. +Anthony recommends this proposed wording:

    + +

    -Move to Open. +In 30.3.1.5 [thread.thread.member] change:

    + +
    void detach();
+
    +
    +

    ...

    +

    -14- Error conditions:

    +
      +
    • ...
      • +
    • invalid_argument -- not a detachable thread.
      • +
    +
    + +
    + +
    +

    [ -2009-07 Frankfurt: +2009-10 Santa Cruz: ]

    -Leave this open pending the removal of concepts from the WD. +Mark as Ready with proposed resolution from Summit.

    Proposed resolution:

    -
      -
    1. -

      -In 20.5.2 [tuple.tuple], class tuple just before member swap please -change as indicated: -

      -

      [ -This fixes an editorial loss between N2798 to N2800 -]

      - -
      template <class... UTypes>
-requires HasAssign<Types, const UTypes&>...
-tuple& operator=(const pair<UTypes...>&);
 
-template <class... UTypes>
-requires HasAssign<Types, RvalueOf<UTypes>::type>...
-tuple& operator=(pair<UTypes...>&&);
-
      -
      2. -

    2. -In 20.5.2.1 [tuple.cnstr], starting just before p. 11 please remove -as indicated: +In 30.3.1.5 [thread.thread.member] change:

      -
      requires MoveAssignable<Types>... tuple& operator=(tuple&& u);
+
      void detach();
 
      
 
      
-
      
--11- Effects: Move-assigns each element of u to the corresponding
-element of *this.
-
      
-
      
--12- Returns: *this.
-
      
+
      ...
      
+
      -14- Error conditions:
      
+
        
+
      • no_such_process --  if the thread is not a valid thread.
        • 
+
      • invalid_argument -- if the thread is not a detachable joinable thread.
        • 
+
      
 
      
+
 
      
-
      3. -
    +
    -

    919. (forward_)list specialized remove algorithms are over constrained

    -

    Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: Open - Submitter: Daniel Krügler Opened: 2008-10-06 Last modified: 2009-07-21

    -

    View other active issues in [forwardlist.ops].

    -

    View all other issues in [forwardlist.ops].

    +

    964. Various threading bugs #14

    +

    Section: 30.5.2 [thread.condition.condvarany] Status: Open + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

    +

    View other active issues in [thread.condition.condvarany].

    +

    View all other issues in [thread.condition.condvarany].

    View all issues with Open status.

    Discussion:

    -The signatures of forwardlist::remove and list::remove -defined in 23.3.3.5 [forwardlist.ops] before 11 + 23.3.4.4 [list.ops] before 15: +The requirements for the constructor for condition_variable has several +error conditions, but the requirements for the constructor for +condition_variable_any has none. Is this difference intentional?

    -
    requires EqualityComparable<T> void remove(const T& value);
-
    +

    [ +Summit: +]

    -

    -are asymmetric to their predicate variants (which only require -Predicate, not EquivalenceRelation) and with the free algorithm -remove (which only require HasEqualTo). Also, nothing in the -pre-concept WP -N2723 -implies that EqualityComparable should -be the intended requirement. -

    + +
    +Move to open, pass to Howard. If this is intentional, a note may be +helpful. If the error conditions are to be copied from +condition_variable, this depends on LWG 965. +

    [ -Batavia (2009-05): +Post Summit Howard adds: ]

    +
    -

    -We agree with the proposed resolution, -but would like additional input from concepts experts. -

    -

    -Move to Review. -

    +The original intention +(N2447) +was to let the OS return whatever errors it was going to return, and for +those to be translated into exceptions, for both +condition_variable and condition_variable_any. I have not +received any complaints about specific error conditions from vendors on +non-POSIX platforms, but such complaints would not surprise me if they surfaced.

    [ -2009-07-21 Alisdair adds: +2009-10 Santa Cruz: ]

    -Current rationale and wording for this issue is built around concepts. I -suggest the issue reverts to Open status.  I believe there is enough of -an issue to review after concepts are removed from the WP to re-examine -the issue in Santa Cruz, rather than resolve as NAD Concepts. +Leave open. Benjamin to provide wording.
    -

    Proposed resolution:

    -
      -
    1. -

      -Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] before 15 -

      - -
      requires EqualityComparable<T> HasEqualTo<T, T> void remove(const T& value);
-
      -
      2. -
    +

    Proposed resolution:

    -

    920. Ref-qualification support in the library

    -

    Section: 20.7.15 [func.memfn] Status: Open - Submitter: Bronek Kozicki Opened: 2008-10-06 Last modified: 2009-05-23

    +

    966. Various threading bugs #16

    +

    Section: 30.5.1 [thread.condition.condvar] Status: Open + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-26

    +

    View other active issues in [thread.condition.condvar].

    +

    View all other issues in [thread.condition.condvar].

    View all issues with Open status.

    Discussion:

    -Daniel Krügler wrote: +30.5.1 [thread.condition.condvar]: +condition_variable::wait and +condition_variable::wait_until both have a postcondition that +lock is locked by the calling thread, and a throws clause that +requires throwing an exception if this postcondition cannot be achieved. +How can the implementation detect that this lock can never be +obtained?

    +

    [ +Summit: +]

    + + +
    +Move to open. Requires wording. Agreed this is an issue, and the +specification should not require detecting deadlocks. +
    + +

    [ +2009-08-01 Howard provides wording. +]

    + +

    -Shouldn't above list be completed for &- and &&-qualified -member functions This would cause to add: +The proposed wording is inspired by the POSIX spec which says:

    -
    template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) &);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) const &);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) volatile &);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) &&);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) const &&);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
-template<Returnable R, class T, CopyConstructible... Args>
-unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
-
    +
    +
    +
    [EINVAL]
    +
    The value specified by cond or mutex is invalid.
    +
    [EPERM]
    +
    The mutex was not owned by the current thread at the time of the call.
    +

    -yes, absolutely. Thanks for spotting this. Without this change mem_fn -cannot be initialized from pointer to ref-qualified member function. I -believe semantics of such function pointer is well defined. +I do not believe [EINVAL] is possible without memory corruption (which we don't +specify). [EPERM] is possible if this thread doesn't own the mutex, which is +listed as a precondition. "May" is used instead of "Shall" because not all +OS's are POSIX.

    +

    [ -Post Summit Daniel provided wording. +2009-10 Santa Cruz: ]

    +
    +Leave open, Detlef to provide improved wording. +
    +

    [ -Batavia (2009-05): +2009-10-23 Detlef Provided wording. ]

    +

    -We need to think about whether we really want to go down the proposed path -of combinatorial explosion. -Perhaps a Note would suffice. -

    -

    -We would really like to have an implementation before proceeding. +Detlef's wording put in Proposed resolution. Original wording here:

    +

    -Move to Open, and recommend this be deferred until after the next -Committee Draft has been issued. +Change 30.5.1 [thread.condition.condvar] p12, p19 and +30.5.2 [thread.condition.condvarany] p10, p16:

    -
    +
    +Throws: May throw std::system_error + +if a precondition is not met. + +when the effects or postcondition +cannot be achieved. +
    +
    +
    -

    Proposed resolution:

    -
      -
    1. -

      -In 20.7 [function.objects]/2, header <functional> synopsis, just after -the section "// 20.6.15, member function adaptors::" add the following -declarations to the existing list: -

      -
      template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &&);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &&);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
-
      -
      2. -
    2. -

      -In 20.7.15 [func.memfn] add the following declarations to the existing -list: -

      -
      template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) &&);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const &&);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) volatile &&);
-template<Returnable R, class T, CopyConstructible... Args>
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile &&);
-
      -
      3. -
    -

    -The following text, most notably p.2 and p.3 which discuss influence -of the cv-qualification on the definition of the base class's first template -parameter remains unchanged. -

    +

    [ +2009-10 Santa Cruz: +]

    +
    +Leave open, Detlef to provide improved wording. +
    -
    -

    921. Rational Arithmetic should use template aliases

    -

    Section: 20.4.1 [ratio.ratio] Status: Review - Submitter: Pablo Halpern Opened: 2008-10-07 Last modified: 2009-07-21

    -

    View other active issues in [ratio.ratio].

    -

    View all other issues in [ratio.ratio].

    -

    View all issues with Review status.

    -

    Discussion:

    +

    Proposed resolution:

    -The compile-time functions that operate on ratio<N,D> require the -cumbersome and error-prone "evaluation" of a type member using a -meta-programming style that predates the invention of template aliases. -Thus, multiplying three ratios a, b, and c requires the expression: +Replace 30.5.1 [thread.condition.condvar] p12, p19 and +30.5.2 [thread.condition.condvarany] p10, p16:

    -
    ratio_multiply<a, ratio_multiply<b, c>::type>::type
-
    +
    +

    +Throws: std::system_error when the effects or +postcondition cannot be achieved. +

    +

    +Error conditions: +

    +
      +
    • +equivalent error condition from lock.lock() or lock.unlock(). +
      • +
    -

    -The simpler expression: -

    +

    +Throws: It's implementation-defined whether a std::system_error +with implementation-defined error condition is thrown if the +precondition is not met. +

    +
    -
    ratio_multiply<a, ratio_multiply<b, c>>
-
    -

    -Could be used by if template aliases were employed in the definitions. -

    -

    [ -Post Summit: -]

    -
    -

    -Jens: not a complete proposed resolution: "would need to make similar change" -

    -

    -Consensus: We agree with the direction of the issue. -

    + +
    +

    967. Various threading bugs #17

    +

    Section: 30.3.1.2 [thread.thread.constr] Status: Ready + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22

    +

    View other active issues in [thread.thread.constr].

    +

    View all other issues in [thread.thread.constr].

    +

    View all issues with Ready status.

    +

    Discussion:

    -Recommend Open. +the error handling for the constructor for condition_variable +distinguishes lack of memory from lack of other resources, but the error +handling for the thread constructor does not. Is this difference +intentional?

    -

    [ -2009-05-11 Daniel adds: +Beman has volunteered to provide proposed wording. ]

    -
    -

    -Personally I'm not in favor for the addition of: -

    -
    typedef ratio type;
-
    -

    -For a reader of the -standard it's usage or purpose is unclear. I haven't seen similar examples -of attempts to satisfy non-feature complete compilers. -

    -
    -

    [ -2009-05-11 Pablo adds: +2009-09-25 Beman provided proposed wording. ]

    -

    -The addition of type to the ratio template allows the previous style -(i.e., in the prototype implementations) to remain valid and permits the -use of transitional library implementations for C++03 compilers. I do -not feel strongly about its inclusion, however, and leave it up to the -reviewers to decide. -

    +The proposed resolution assumes 962 has been accepted and +its proposed resolution applied to the working paper.

    [ -Batavia (2009-05): +2009-10 Santa Cruz: ]

    +
    -Bill asks for additional discussion in the issue -that spells out more details of the implementation. -Howard points us to issue 948 -which has at least most of the requested details. -Tom is strongly in favor of overflow-checking at compile time. -Pete points out that there is no change of functionality implied. -We agree with the proposed resolution, -but recommend moving the issue to Review -to allow time to improve the discussion if needed. +Move to Ready.
    -

    [ -2009-07-21 Alisdair adds: -]

    -
    -See 1121 for a potentially incompatible proposal. -
    +

    Proposed resolution:

    -

    Proposed resolution:

    +

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], +paragraph 4, as indicated:

    +
    - -
      -
    1. -

      -In 20.4 [ratio]/3 change as indicated: -

      +

      Error conditions:

      +
      -
      // ratio arithmetic
-template <class R1, class R2> structusing ratio_add = see below;
-template <class R1, class R2> structusing ratio_subtract = see below;
-template <class R1, class R2> structusing ratio_multiply = see below;
-template <class R1, class R2> structusing ratio_divide = see below;
-
      -
      2. -
    2. -

      -In 20.4.1 [ratio.ratio], change as indicated: -

      -
      namespace std {
-  template <intmax_t N, intmax_t D = 1>
-  class ratio {
-  public:
-    typedef ratio type;
-    static const intmax_t num;
-    static const intmax_t den;
-  };
-}
-
      -
      3. -
    3. -

      -In 20.4.2 [ratio.arithmetic] change as indicated: -

      +
        +
      • not_enough_memory — if there is not enough memory to construct +the mutex object.
        • -
        template <class R1, class R2> structusing ratio_add = see below{
-  typedef see below type;
-};
-
        +
      • resource_unavailable_try_again — if any native handle type +manipulated is not available.
        • -
        -

        -1 The nested typedef type ratio_add<R1, R2> -shall be a synonym for ratio<T1, T2> -where T1 has the value R1::num * R2::den + R2::num * R1::den and T2 -has the value R1::den * R2::den. -

        -
        -
        -
        template <class R1, class R2> structusing ratio_subtract = see below{
-  typedef see below type;
-};
-
        -
        -

        -2 The nested typedef type ratio_subtract<R1, R2> -shall be a synonym for ratio<T1, T2> -where T1 has the value R1::num * R2::den - R2::num * R1::den and T2 -has the value R1::den * R2::den. -

        -
        -
        -
        template <class R1, class R2> structusing ratio_multiply = see below{
-  typedef see below type;
-};
-
        -
        -

        -3 The nested typedef type ratio_multiply<R1, R2> -shall be a synonym for ratio<T1, T2> -where T1 has the value R1::num * R2::num and T2 has the value R1::den * R2::den. -

        -
        -
        -
        template <class R1, class R2> structusing ratio_divide = see below{
-  typedef see below type;
-};
-
        -
        -

        -4 The nested typedef type ratio_divide<R1, R2> -shall be a synonym for ratio<T1, T2> -where T1 has the value R1::num * R2::den and T2 has the value R1::den * R2::num. -

        -
        -
        - -
      • -

        -In 20.9.3.1 [time.duration.cons]/4 change as indicated: -

        -
        -

        -Requires: treat_as_floating_point<rep>::value shall be true or -ratio_divide<Period2, period>::type::den shall be 1.[..] -

        +
      • operation_not_permitted — if the thread does not have the +necessary permission to change the state of the mutex object.
        • + +
      • device_or_resource_busy — if any native handle type +manipulated is already locked.
        • + +
      • invalid_argument — if any native handle type manipulated as +part of mutex construction is incorrect.
        • +
      +
    - -
  • -

    -In 20.9.3.7 [time.duration.cast]/2 change as indicated: -

    + +

    Change Class condition_variable 30.5.1 [thread.condition.condvar], +default constructor, as indicated:

    -

    -Returns: Let CF be ratio_divide<Period, typename -ToDuration::period>::type, and [..] -

    +

    condition_variable();

    +
    +

    Effects: Constructs an object of type condition_variable.

    +

    Throws: std::system_error when an exception is required (30.2.2 [thread.req.exception]).

    +

    Error conditions:

    +
    +
      +
    • not_enough_memory — if a memory limitation prevents + initialization.
      • +
    • resource_unavailable_try_again — if some non-memory + resource limitation prevents initialization.
      • +
    • device_or_resource_busy — if attempting to initialize a + previously-initialized but as of yet undestroyed condition_variable.
      • +
    +
    +
    -
    • -
    -

    923. atomics with floating-point

    -

    Section: 29 [atomics] Status: Open - Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2009-05-01

    -

    View other active issues in [atomics].

    -

    View all other issues in [atomics].

    -

    View all issues with Open status.

    +

    968. Various threading bugs #18

    +

    Section: 30.4.1 [thread.mutex.requirements] Status: Ready + Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-10-22

    +

    View other active issues in [thread.mutex.requirements].

    +

    View all other issues in [thread.mutex.requirements].

    +

    View all issues with Ready status.

    Discussion:

    -Right now, C++0x doesn't have atomic<float>. We're thinking of adding -the words to support it for TR2 (note: that would be slightly -post-C++0x). If we need it, we could probably add the words. -

    -

    -Proposed resolutions: Using atomic<FP>::compare_exchange (weak or -strong) should be either: -

    - -
      -
    1. -ill-formed, or -
      2. -
    2. -well-defined. -
      3. -
    - -

    -I propose Option 1 for C++0x for expediency. If someone wants to argue -for Option 2, they need to say what exactly they want compare_exchange -to mean in this case (IIRC, C++0x doesn't even assume IEEE 754). +30.4.1 [thread.mutex.requirements]: several functions are +required to throw exceptions "if the thread does not have the necessary +permission ...". "The necessary permission" is not defined.

    [ Summit: ]

    -
    -Move to open. Blocked until concepts for atomics are addressed. +Move to open.
    +

    [ -Post Summit Anthony adds: +Beman has volunteered to provide proposed wording. ]

    -
    -

    -Recommend NAD. C++0x does have std::atomic<float>, and both -compare_exchange_weak and compare_exchange_strong are well-defined in -this case. Maybe change the note in 29.6 [atomics.types.operations] paragraph 20 to: -

    - -
    -

    -[Note: The effect of the compare-and-exchange operations is -

    -
    if (!memcmp(object,expected,sizeof(*object)))
-    *object = desired;
-else
-    *expected = *object;
-
    +

    [ +2009-10 Santa Cruz: +]

    -

    -This may result in failed comparisons for values that compare equal if -the underlying type has padding bits or alternate representations of -the same value. -- end note] -

    -
    +
    +Moved to Ready with minor word-smithing in the example.

    Proposed resolution:

    -

    -Change the note in 29.6 [atomics.types.operations] paragraph 20 to: -

    - -
    -

    -[Note: The effect of the compare-and-exchange operations is -

    -
    if (*object == *expected !memcmp(object,expected,sizeof(*object)))
-    *object = desired;
-else
-    *expected = *object;
-
    -

    -This may result in failed comparisons for values that compare equal if -the underlying type has padding bits or alternate representations of -the same value. -- end note] -

    -
    +

    Change Exceptions 30.2.2 [thread.req.exception] as indicated:

    +
    +

    Some functions described in this Clause are +specified to throw exceptions of type system_error (19.5.5). Such exceptions +shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API +results in an error that prevents the library function from meeting its specifications. +[Note: See 17.6.4.11 [res.on.exception.handling] for exceptions thrown to report +storage allocation failures. —end +note]

    +

    [Example:

    +
    +

    Consider a function in this clause that is specified to throw exceptions of type +system_error and specifies Error conditions that include +operation_not_permitted for a thread that does not have the privilege to +perform the operation. Assume that, during the execution of this function, an errno +of EPERM is reported by a POSIX API call used by the +implementation. Since POSIX specifies an errno of EPERM +when "the caller does not have the privilege to perform the operation", +the implementation maps EPERM  to an error_condition +of operation_not_permitted (19.5 [syserr]) and an exception of type +system_error is thrown.

    +
    -
    -

    924. structs with internal padding

    -

    Section: 29 [atomics] Status: Open - Submitter: Herb Sutter Opened: 2008-10-17 Last modified: 2009-03-22

    -

    View other active issues in [atomics].

    -

    View all other issues in [atomics].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    -Right now, the compare_exchange_weak loop should rapidly converge on the -padding contents. But compare_exchange_strong will require a bit more -compiler work to ignore padding for comparison purposes. -

    -

    -Note that this isn't a problem for structs with no padding, and we do -already have one portable way to ensure that there is no padding that -covers the key use cases: Have elements be the same type. I suspect that -the greatest need is for a structure of two pointers, which has no -padding problem. I suspect the second need is a structure of a pointer -and some form of an integer. If that integer is intptr_t, there will be -no padding. -

    -

    -Related but separable issue: For unused bitfields, or other unused -fields for that matter, we should probably say it's the programmer's -responsibility to set them to zero or otherwise ensure they'll be -ignored by memcmp. -

    +

    —end example]

    -

    -Proposed resolutions: Using -atomic<struct-with-padding>::compare_exchange_strong should be either: -

    +

    Editorial note: For the sake of exposition, +the existing text above is shown with the changes proposed in issues 962 and 967. The +proposed additional example is independent of whether or not the 962 and 967 +proposed resolutions are accepted.

    -
      -
    1. -ill-formed, or -
      2. -
    2. -well-defined. -
      3. -
    +
    -

    -I propose Option 1 for C++0x for expediency, though I'm not sure how to -say it. I would be happy with Option 2, which I believe would mean that -compare_exchange_strong would be implemented to avoid comparing padding -bytes, or something equivalent such as always zeroing out padding when -loading/storing/comparing. (Either implementation might require compiler -support.) -

    +

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], +paragraph 4, as indicated:

    -

    [ -Summit: -]

    +
    +

    — operation_not_permitted — if the thread does not have the +necessary permission to change the state of the mutex object privilege to perform the operation.

    -
    -Move to open. Blocked until concepts for atomics are addressed.
    -

    [ -Post Summit Anthony adds: -]

    - +

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], +paragraph 12, as indicated:

    -The resoultion of LWG 923 should resolve this issue as well. -
    +

    — operation_not_permitted — if the thread does not have the +necessary permission to change the state of the mutex privilege to perform the operation.

    +
    -

    Proposed resolution:

    -

    -

    -

    926. Sequentially consistent fences, relaxed operations and modification order

    -

    Section: 29.3 [atomics.order] Status: Open - Submitter: Anthony Williams Opened: 2008-10-19 Last modified: 2009-03-22

    -

    View all other issues in [atomics.order].

    -

    View all issues with Open status.

    +

    974. duration<double> should not implicitly convert to duration<int>

    +

    Section: 20.9.3.1 [time.duration.cons] Status: Ready + Submitter: Howard Hinnant Opened: 2009-01-21 Last modified: 2009-10-26

    +

    View all issues with Ready status.

    Discussion:

    -

    Addresses UK 313

    -

    -There was an interesting issue raised over on comp.programming.threads -today regarding the following example +The following code should not compile because it involves implicit truncation +errors (against the design philosophy of the duration library).

    -
    // Thread 1:
-x.store(1, memory_order_relaxed);           // SX
-atomic_thread_fence(memory_order_seq_cst);  // F1
-y.store(1, memory_order_relaxed);           // SY1
-atomic_thread_fence(memory_order_seq_cst);  // F2
-r1 = y.load(memory_order_relaxed);          // RY
-
-// Thread 2:
-y.store(0, memory_order_relaxed);          // SY2
-atomic_thread_fence(memory_order_seq_cst); // F3
-r2 = x.load(memory_order_relaxed);         // RX
+
    duration<double> d(3.5);
+duration<int> i = d;  // implicit truncation, should not compile
 
    
 
 
    
-is the outcome r1 == 0 and r2 == 0 possible?
-
    
-
    
-I think the intent is that this is not possible, but I am not sure the
-wording guarantees that. Here is my analysis:
-
    
-
    
-Since all the fences are SC, there must be a total order between them.
-F1 must be before F2 in that order since they are in
-the same thread. Therefore F3 is either before F1,
-between F1 and F2 or after F2.
-
    
-
    
-If F3 is after F2, then we can apply 29.3 [atomics.order]p5 from
-N2798:
+This intent was codified in the example implementation which drove this proposal
+but I failed to accurately translate the code into the specification in this
+regard.
 
    
 
-
    
-For atomic operations A and B on an atomic object
-M, where A modifies M and B takes
-its value, if there are memory_order_seq_cst fences X
-and Y such that A is sequenced before X,
-Y is sequenced before B, and X precedes
-Y in S, then B observes either the effects of
-A or a later modification of M in its modification
-order.
-
    
+
    [
+Batavia (2009-05):
+]
    
 
+
    
 
    
-In this case, A is SX, B is RX, the
-fence X is F2 and the fence Y is F3,
-so RX must see 1.
-
    
-
    
-If F3 is before F2, this doesn't apply, but
-F3 can therefore be before or after F1.
-
    
-
    
-If F3 is after F1, the same logic applies, but this
-time the fence X is F1. Therefore again, RX
-must see 1.
-
    
-
    
-Finally we have the case that F3 is before F1
-in the SC ordering. There are now no guarantees about RX, and
-RX can see r2==0.
-
    
-
    
-We can apply 29.3 [atomics.order]p5 again. This time,
-A is SY2, B is RY, X is
-F3 and Y is F1. Thus RY must observe
-the effects of SY2 or a later modification of y in its
-modification order.
-
    
-
    
-Since SY1 is sequenced before RY, RY must
-observe the effects of SY1 or a later modification of
-y in its modification order.
-
    
-
    
-In order to ensure that RY sees (r1==1), we must see
-that SY1 is later in the modification order of y than
-SY2.
+We agree with the proposed resolution.
 
    
 
    
-We're now skating on thin ice. Conceptually, SY2 happens-before
-F3, F3 is SC-ordered before F1, F1
-happens-before SY1, so SY1 is later in the
-modification order M of y, and RY must see
-the result of SY1 (r1==1). However, I don't think the
-words are clear on that.
+Move to Tentatively Ready.
 
    
+
    
 
 
    [
-Post Summit Hans adds:
+2009-07 Frankfurt
 ]
    
 
 
 
    
-
    
-In my (Hans') view, our definition of fences will always be weaker than
-what particular hardware will guarantee.  Memory_order_seq_cst fences
-inherently don't guarantee sequential consistency anyway, for good
-reasons (e.g. because they can't enforce a total order on stores).
- Hence I don't think the issue demonstrates a gross failure to achieve
-what we intended to achieve.  The example in question is a bit esoteric.
- Hence, in my view, living with the status quo certainly wouldn't be a
-disaster either.
-
    
-
    
-In any case, we should probably add text along the lines of the
-following between p5 and p6 in 29.3 [atomics.order]:
-
    
-
    
-[Note: Memory_order_seq_cst only ensures sequential consistency for a
-data-race-free program that uses exclusively memory_order_seq_cst
-operations.  Any use of weaker ordering will invalidate this guarantee
-unless extreme care is used.  In particular, memory_order_seq_cst fences
-only ensure a total order for the fences themselves.  They cannot, in
-general, be used to restore sequential consistency for atomic operations
-with weaker ordering specifications.]
+Moved from Tentatively Ready to Open only because the wording needs to be
+improved for enable_if type constraining, possibly following Robert's
+formula.
 
    
 
-
    
-Also see thread beginning at c++std-lib-23271.
-
    
+
    [
+2009-08-01 Howard adds:
+]
    
 
+
+
    
+Addressed by 1177.
 
    
 
 
    [
-Herve's correction:
+2009-10 Santa Cruz:
 ]
    
 
-
    
-
    
-Minor point, and sorry for the knee jerk reaction: I admit to having
-no knowledge of Memory_order_seq_cst, but my former boss (John Lakos)
-has ingrained an automatic introspection on the use of "only".   I
-think you meant:
-
    
 
 
    
-[Note: Memory_order_seq_cst ensures sequential consistency only
-for . . . .  In particular, memory_order_seq_cst fences ensure a
-total order only for . . .
-
    
-
    
-Unless, of course, Memory_order_seq_cst really do nothing but ensure
-sequential consistency for a data-race-free program that uses
-exclusively memory_order_seq_cst operations.
-
    
+Not completely addressed by 1177.  Move to Ready.
 
    
 
 
 
 
    Proposed resolution:
    
 
    
-Add a new paragraph after 29.3 [atomics.order]p5 that says
+Change 20.9.3.1 [time.duration.cons], p4:
 
    
 
 
    
-For atomic operations A and B on an atomic object
-M, where A and B modify M, if there
-are memory_order_seq_cst fences X and Y such
-that A is sequenced before X, Y is sequenced
-before B, and X precedes Y in S,
-then B occurs later than A in the modifiction order of
-M.
+
    template <class Rep2, class Period2> 
+  duration(const duration<Rep2, Period2>& d);
+
    
+
    
+-4- Requires: treat_as_floating_point<rep>::value
+shall be true or both ratio_divide<Period2,
+period>::type::den shall be 1
+and treat_as_floating_point<Rep2>::value
+shall be false.
+Diagnostic required.
+[Note: This requirement prevents implicit truncation error when
+converting between integral-based duration types. Such a
+construction could easily lead to confusion about the value of the
+duration. -- end note]
+
    
 
    
 
 
@@ -17347,978 +14463,823 @@ then B occurs later than A in the modifiction order of
 
 
 
    
-
    929. Thread constructor
    
-
    Section: 30.3.1.2 [thread.thread.constr] Status: Open
- Submitter: Anthony Williams Opened: 2008-10-23  Last modified: 2009-07-18
    
-
    View other active issues in [thread.thread.constr].
    
-
    View all other issues in [thread.thread.constr].
    
-
    View all issues with Open status.
    
+
    978. Hashing smart pointers
    
+
    Section: 20.7.16 [unord.hash] Status: Ready
+ Submitter: Alisdair Meredith Opened: 2009-02-02  Last modified: 2009-10-27
    
+
    View other active issues in [unord.hash].
    
+
    View all other issues in [unord.hash].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
-
    Addresses UK 323
    
-
-
    
-The thread constructor for starting a new thread with a function and
-arguments is overly constrained by the signature requiring rvalue
-references for func and args and the CopyConstructible requirements
-for the elements of args. The use of an rvalue reference for the
-function restricts the potential use of a plain function name, since
-the type of the bound parameter will be deduced to be a function
-reference and decay to pointer-to-function will not happen. This
-therefore complicates the implementation in order to handle a simple
-case. Furthermore, the use of rvalue references for args prevents the
-array to pointer decay. Since arrays are not CopyConstructible or even
-MoveConstructible, this essentially prevents the passing of arrays as
-parameters. In particular it prevents the passing of string literals.
-Consequently a simple case such as
-
    
-
-
    void f(const char*);
-std::thread t(f,"hello");
-
    
-
-
    
-is ill-formed since the type of the string literal is const char[6].
-
    
-
-
    
-By changing the signature to take all parameters by value we can
-eliminate the CopyConstructible requirement and permit the use of
-arrays, as the parameter passing semantics will cause the necessary
-array-to-pointer decay. They will also cause the function name to
-decay to a pointer to function and allow the implementation to handle
-functions and function objects identically.
-
    
-
+
    Addresses UK 208
    
 
    
-The new signature of the thread constructor for a function and
-arguments is thus:
+I don't see an open issue on supporting std::hash for smart pointers
+(unique_ptr and shared_ptr at least).
 
    
-
-
    template<typename F,typename... Args>
-thread(F,Args... args);
-
    
-
 
    
-Since the parameter pack Args can be empty, the single-parameter
-constructor that takes just a function by value is now redundant.
+It seems reasonable to at least expect support for the smart
+pointers, especially as they support comparison for use in ordered
+associative containers.
 
    
 
 
    [
-Howard adds:
+Batavia (2009-05):
 ]
    
 
-
 
    
 
    
-I agree with everything Anthony says in this issue.  However I believe we
-can optimize in such a way as to get the pass-by-value behavior with the
-pass-by-rvalue-ref performance.  The performance difference is that the latter
-removes a move when passing in an lvalue.
+Howard points out that the client can always supply a custom hash function.
 
    
-
 
    
-This circumstance is very analogous to make_pair (20.3.3 [pairs])
-where we started with passing by const reference, changed to pass by value to
-get pointer decay, and then changed to pass by rvalue reference, but modified with
-decay<T> to retain the pass-by-value behavior.  If we were to
-apply the same solution here it would look like:
+Alisdair replies that the smart pointer classes are highly likely
+to be frequently used as hash keys.
 
    
-
-
    template <class F> explicit thread(F f);
-template <class F, class ...Args> thread(F&& f, Args&&... args);
-
    
-
    
 
    
--4- Requires: F and each Ti in Args shall be CopyConstructible
-if an lvalue and otherwise MoveConstructible.
-INVOKE(f, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for
-some values w1, w2, ... , wN, where N == sizeof...(Args).
+Bill would prefer to be conservative.
 
    
 
    
--5- Effects: Constructs an object of type thread
-and executes INVOKE(f, t1, t2, ..., tN) in a new
-thread of execution, where t1, t2, ..., tN are the values in args....
-Constructs
-the following objects in memory which is accessible to a new thread of execution
-as if:
+Alisdair mentions that this issue may also be viewed as a subissue or
+duplicate of issue 1025.
 
    
-
    typename decay<F>::type g(std::forward<F>(f));
-tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);
-
    
 
    
-The new thread of
-execution executes INVOKE(g, wi...) where the wi... refers
-to the elements stored in the tuple w.
-Any return value from g is ignored.
-If f terminates with an uncaught exception, std::terminate() shall be called.
-If the evaluation of INVOKE(g,  wi...) terminates
-with an uncaught exception, std::terminate() shall be called [Note:
-std::terminate() could be called before entering g. -- end note]. Any
-exception thrown before the evaluation of INVOKE has started shall be
-catchable in the calling thread.
+Move to Open, and recommend the issue be deferred until after the next
+Committee Draft is issued.
 
    
 
    
-
    
 
+
    [
+2009-05-31 Peter adds:
+]
    
+
+
+
    
+
    
+Howard points out that the client can always supply a custom hash function.
+
    
 
    
-Text referring to when terminate() is called was contributed by Ganesh.
+Not entirely true. The client cannot supply the function that hashes the
+address of the control block (the equivalent of the old operator<, now
+proudly carrying the awkward name of 'owner_before'). Only the
+implementation can do that, not necessarily via specializing hash<>, of
+course.
+
    
+
    
+This hash function makes sense in certain situations for shared_ptr
+(when one needs to switch from set/map using ownership ordering to
+unordered_set/map) and is the only hash function that makes sense for
+weak_ptr.
 
    
-
 
    
 
 
    [
-Batavia (2009-05):
+2009-07-28 Alisdair provides wording.
 ]
    
 
-
    
-We agree with the proposed resolution,
-but would like the final sentence to be reworded
-since "catchable" is not a term of art (and is used nowhere else).
-
    
 
 
    [
-2009-07 Frankfurt:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-
    
-This is linked to
-N2901.
-
    
-
    
-Howard to open a separate issue to remove (1176).
-
    
-
    
-In Frankfurt there is no consensus for removing the variadic constructor.
-
    
+Move to Ready.
 
    
 
 
 
 
    Proposed resolution:
    
 
    
-Modify the class definition of std::thread in 30.3.1 [thread.thread.class] to remove the
-following signature:
+Add the following declarations to the synopsis of <memory>
+in 20.8 [memory]
 
    
 
-
    template<class F> explicit thread(F f);
-template<class F, class ... Args> explicit thread(F&& f, Args&& ... args);
+
    // 20.8.10.X hash support
+template <class T> struct hash;
+template <class T, class D> struct hash<unique_ptr<T,D>>;
+template <class T> struct hash<shared_ptr<T>>;
 
    
 
 
    
-Modify 30.3.1.2 [thread.thread.constr] to replace the constructors prior to paragraph 4 with
-the single constructor as above. Replace paragraph 4 - 6 with the
-following:
+Add a new subclause 20.8.10.X hash support
 
    
 
 
    
 
    
--4- Requires: F and each Ti in Args shall be CopyConstructible
-if an lvalue and otherwise MoveConstructible.
-INVOKE(f, w1, w2, ..., wN) (20.7.2 [func.require]) shall be a valid expression for
-some values w1, w2, ... , wN, where N == sizeof...(Args).
-
    
-
    
--5- Effects: Constructs an object of type thread
-and executes INVOKE(f, t1, t2, ..., tN) in a new
-thread of execution, where t1, t2, ..., tN are the values in args....
-Constructs
-the following objects:
+20.8.10.X hash support [util.smartptr.hash]
 
    
-
    typename decay<F>::type g(std::forward<F>(f));
-tuple<typename decay<Args>::type...> w(std::forward<Args>(args)...);
-
    
-
    
-and executes INVOKE(g, wi...) in a new thread of execution.
-These objects shall be destroyed when the new thread of execution completes.
-Any return value from g is ignored.
-If f terminates with an uncaught exception, std::terminate() shall be called.
-If the evaluation of INVOKE(g,  wi...) terminates
-with an uncaught exception, std::terminate() shall be called [Note:
-std::terminate() could be called before entering g. -- end note]. Any
-exception thrown before the evaluation of INVOKE has started shall be
-catchable in the calling thread.
-
    
-
    
--6- Synchronization: The invocation of the constructor happens before the
-invocation of f g.
-
    
-
    
-
-
-
-
 
-
-
    
-
    930. Access to std::array data as built-in array type
    
-
    Section: 23.3.1 [array] Status: Review
- Submitter: Niels Dekker Opened: 2008-11-17  Last modified: 2009-07-31
    
-
    View other active issues in [array].
    
-
    View all other issues in [array].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
-
-
    
-The Working Draft (N2798) allows access to the elements of
-std::array by its data() member function:
-
    
+
    template <class T, class D> struct hash<unique_ptr<T,D>>;
+
    
 
 
    
-
-
    23.2.1.4 array::data [array.data]
    
-
     T *data();
- const T *data() const;
-
    
-
    1. 
- Returns: elems.
-
    
+A partial specialization of the class template hash (20.7.16 [unord.hash]) shall be provided for instances of the
+unique_ptr template suitable for use as a key in unordered
+associative containers (23.5 [unord]) if and only if there is a
+hash specialization available for the type D::pointer.
+For an object p of type unqiue_ptr<T,D> the
+hash shall evaluate to the same value as hash<typename
+D::pointer>{}(p.get()).
 
    
 
-
    
-Unfortunately, the result of std::array::data() cannot be bound
-to a reference to a built-in array of the type of array::elems.
-And std::array provides no other way to get a reference to
-array::elems. 
-This hampers the use of std::array, for example when trying to
-pass its data to a C style API function:
-
    
-
-
     // Some C style API function. 
- void set_path( char (*)[MAX_PATH] );
-
- std::array<char,MAX_PATH> path;
- set_path( path.data() );  // error
- set_path( &(path.data()) );  // error
+
    template <class T> struct hash<shared_ptr<T>>;
 
    
 
- 
    
-Another example, trying to pass the array data to an instance of another
-C++ class:
-
    
+
    
+A partial specialization of the class template hash (20.7.16 [unord.hash])
+shall be provided for instances of the shared_ptr template
+suitable for use as a key in unordered associative containers
+(23.5 [unord]). For an object p of type shared_ptr<T>
+the hash shall evaluate
+to the same value as hash<T*>{}(p.get()).
+
    
+
    
+
 
-
     // Represents a 3-D point in space.
- class three_d_point {
- public:
-   explicit three_d_point(const double (&)[3]); 
- };
 
- const std::array<double,3> coordinates = { 0, 1, 2 };
- three_d_point point1( coordinates.data() );  // error.
- three_d_point point2( *(coordinates.data()) );  // error.
-
    
 
-
    
-A user might be tempted to use std::array::elems instead, but
-doing so isn't recommended, because std::array::elems is "for
-exposition only".  Note that Boost.Array users might already use
-boost::array::elems, as its documentation doesn't explicitly
-state that boost::array::elems is for exposition only:
-http://www.boost.org/doc/libs/1_36_0/doc/html/boost/array.html
-
    
-
    
-I can think of three options to solve this issue:
-
    
-
    1. 
-Remove the words "exposition only" from the definition of
-std::array::elems, as well as the note saying that "elems is
-shown for exposition only."
-
    2. 
-Change the signature of std::array::data(), so that it would
-return a reference to the built-in array, instead of a pointer to its
-first element.
-
    3. 
-Add extra member functions, returning a reference to the built-in array.
-
    
-
    
-Lawrence Crowl wrote me that it might be better to leave
-std::array::elems "for exposition only", to allow alternate
-representations to allocate the array data dynamically.  This might be
-of interest to the embedded community, having to deal with very limited
-stack sizes.
-
    
-
    
-The second option, changing the return type of
-std::array::data(), would break backward compatible to current
-Boost and TR1 implementations, as well as to the other contiguous
-container (vector and string) in a very subtle way.
-For example, the following call to std::swap currently swap two
-locally declared pointers (data1, data2), for any container
-type T that has a data() member function. When
-std::array::data() is changed to return a reference, the
-std::swap call may swap the container elements instead.
-
    
-
-
     template <typename T>
- void func(T& container1, T& container2)
- {
-   // Are data1 and data2 pointers or references?
-   auto data1 = container1.data();
-   auto data2 = container2.data();
-
-   // Will this swap two local pointers, or all container elements?
-   std::swap(data1, data2);
- }
-
    
 
+
    
+
    983. unique_ptr reference deleters should not be moved from
    
+
    Section: 20.8.14.2 [unique.ptr.single] Status: Ready
+ Submitter: Howard Hinnant Opened: 2009-02-10  Last modified: 2009-10-21
    
+
    View other active issues in [unique.ptr.single].
    
+
    View all other issues in [unique.ptr.single].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-The following concept is currently satisfied by all contiguous
-containers, but it no longer is for std::array, when
-array::data()
-is changed to return a reference (tested on ConceptGCC Alpha 7):
+Dave brought to my attention that when a unique_ptr has a non-const reference
+type deleter, move constructing from it, even when the unique_ptr containing
+the reference is an rvalue, could have surprising results:
 
    
 
-
     auto concept ContiguousContainerConcept<typename T>
- {
-   typename value_type = typename T::value_type;
-   const value_type * T::data() const;
- }
-
    
+
    D d(some-state);
+unique_ptr<A, D&> p(new A, d);
+unique_ptr<A, D> p2 = std::move(p);
+// has d's state changed here?
+
    
 
 
    
-Still it's worth considering having std::array::data() return a
-reference, because it might be the most intuitive option, from a user's
-point of view.  Nicolai Josuttis (who wrote boost::array)
-mailed me that he very much prefers this option.
-
    
-
    
-Note that for this option, the definition of data() would also
-need to be revised for zero-sized arrays, as its return type cannot be a
-reference to a zero-sized built-in array.  Regarding zero-sized array,
-data() could throw an exception.  Or there could be a partial
-specialization of std::array where data() returns
-T* or gets removed.
+I agree with him.  It is the unique_ptr that is the rvalue, not the
+deleter.  When the deleter is a reference type, the unique_ptr should
+respect the "lvalueness" of the deleter.
 
    
+
 
    
-Personally I prefer the third option, adding a new member function to
-std::array, overloaded for const and non-const access,
-returning a reference to the built-in array, to avoid those compatible
-issues. I'd propose naming the function std::array::c_array(),
-which sounds intuitive to me. Note that boost::array already
-has a c_array() member, returning a pointer, but Nicolai told
-me that this one is only there for historical reasons. (Otherwise a name
-like std::array::native_array() or
-std::array::builtin_array() would also be fine with me.) 
-According to my proposed resolution, a zero-sized std::array does not need
-to have c_array(), while it is still required to have
-data() functions.
+Thanks Dave.
 
    
 
 
    [
-Post Summit:
+Batavia (2009-05):
 ]
    
 
-
 
    
+Seems correct, but complicated enough that we recommend moving to Review.
+
    
 
-
    
-Alisdair: Don't like p4 suggesting implementation-defined behaviour.
-
    
-
    
-Walter: What about an explicit conversion operator, instead of adding
-the new member function?
-
    
-
    
-Alisdair: Noodling about:
-
    
-
    template<size_t N, ValueType T>
-struct array
-{
-  T elems[N];
-
-// fantasy code starts here
-
-// crazy decltype version for grins only
-//requires True<(N>0)>
-//explict operator decltype(elems) & () { return elems; }
-
-// conversion to lvalue ref
-requires True<(N>0)>
-explict operator T(&)[N] () & { return elems; }
+
    [
+2009-10 Santa Cruz:
+]
    
 
-// conversion to const lvalue ref
-requires True<(N>0)>
-explict operator const T(&)[N] () const & { return elems; }
 
-// conversion to rvalue ref using ref qualifiers
-requires True<(N>0)>
-explict operator T(&&)[N] () && { return elems; }
+
    
+Move to Ready.
+
    
 
-// fantasy code ends here
 
-explicit operator bool() { return true; }
-};
-
    
 
+
    Proposed resolution:
    
 
    
-This seems legal but odd. Jason Merrill says currently a CWG issue 613
-on the non-static data member that fixes the error that current G++
-gives for the non-explicit, non-conceptualized version of this. Verdict
-from human compiler: seems legal.
-
    
-
    
-Some grumbling about zero-sized arrays being allowed and supported.
-
    
-
    
-Walter: Would this address the issue? Are we inclined to go this route?
-
    
-
    
-Alan: What would usage look like?
+Change 20.8.14.2.1 [unique.ptr.single.ctor], p20-21
 
    
-
    // 3-d point in space
-struct three_d_point
-{
-  explicit three_d_point(const double (&)[3]);
-};
 
-void sink(double*);
+
    
+
    template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);
+
    
 
-const std::array<double, 3> coordinates = { 0, 1, 2 };
-three_d_point point1( coordinates.data() ); //error
-three_d_point point2( *(coordinates.data()) ); // error
-three_d_point point3( coordinates ); // yay!
+
    
 
-sink(cooridinates); // error, no conversion
-
    
+
    
+-20- Requires: If D E is not a reference type,
+construction of the deleter D from an rvalue of type E
+shall be well formed and shall not throw an exception.
+
+Otherwise E is a reference type and construction of the deleter
+D from an lvalue of type E shall be well formed and
+shall not throw an exception.
+
+If D is
+a reference type, then E shall be the same type as D
+(diagnostic required). unique_ptr<U, E>::pointer shall be
+implicitly convertible to pointer. [Note: These
+requirements imply that T and U are complete types.
+-- end note]
+
    
 
 
    
-Recommended Open with new wording. Take the required clause and add the
-explicit conversion operators, not have a typedef. At issue still is use
-decltype or use T[N]. In favour of using T[N], even though use of
-decltype is specially clever.
+-21- Effects: Constructs a unique_ptr which owns the
+pointer which u owns (if any). If the deleter
+E is not a reference type, it this
+deleter is move constructed from u's deleter, otherwise
+the reference this deleter is copy constructed
+from u.'s deleter. After the construction, u no longer
+owns a pointer. [Note: The deleter constructor can be implemented
+with std::forward<DE>. -- end
+note]
 
    
 
+
    
 
    
 
-
    [
-Post Summit, further discussion in the thread starting with c++std-lib-23215.
-]
    
-
-
-
    [
-2009-07 post-Frankfurt (Saturday afternoon group):
-]
    
-
-
-
    
-
    
-The idea to resolve the issue by adding explicit conversion operators
-was abandoned, because it would be inconvenient to use, especially when
-passing the array to a template function, as mentioned by Daniel. So we
-reconsidered the original proposed resolution, which appeared
-acceptable, except for its proposed changes to 23.3.1.6 [array.zero], which
-allowed c_array_type and c_array() to be absent for a zero-sized array.
-Alisdair argued that such wording would disallow certain generic use
-cases. New wording for 23.3.1.6 [array.zero] was agreed upon (Howard: and
-is reflected in the proposed resolution).
-
    
 
    
-Move to Review
+Change 20.8.14.2.3 [unique.ptr.single.asgn], p1-3
 
    
-
    
-
-
    [
-2009-07-31 Alisdair adds:
-]
    
-
 
 
    
+
    unique_ptr& operator=(unique_ptr&& u);
+
    
+
    
+
 
    
-I will be unhappy voting the proposed resolution for 930 past review
-until we have implementation experience with reference qualifiers. 
-Specifically, I want to understand the impact of the missing overload
-for const && (if any.)
+-1- Requires: If the deleter D is not a reference type,
+Aassignment of the deleter D from an rvalue D shall not throw an exception.
+
+Otherwise the deleter D is a reference type,
+and assignment of the deleter D from an lvalue D shall not throw an exception.
 
    
 
 
    
-If we think the issue is important enough it might be worthwhile
-stripping the ref qualifiers for easy progress next meeting, and opening
-yet another issue to put them back with experience.
+-2- Effects: reset(u.release()) followed by
+an move assignment from u's deleter to this deleter
+std::forward<D>(u.get_deleter()).
 
    
 
 
    
-Recommend deferring any decision on splitting the issue until we get LWG
-feedback next meeting - I may be the lone dissenting voice if others are
-prepared to proceed without it.
+-3- Postconditions: This unique_ptr now owns the pointer
+which u owned, and u no longer owns it. [Note: If
+D is a reference type, then the referenced lvalue deleters are
+move assigned. -- end note]
 
    
 
    
+
    
 
-
-
    Proposed resolution:
    
 
    
-Add to the template definition of array, 23.3.1 [array]/3:
+Change 20.8.14.2.3 [unique.ptr.single.asgn], p6-7
 
    
 
 
    
-
    
-typedef T c_array_type[N];
-c_array_type & c_array() &;
-c_array_type && c_array() &&;
-const c_array_type & c_array() const &;
-
+
    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);
 
    
-
    
+
    
 
 
    
-Add the following subsection to 23.3.1 [array], after 23.3.1.4 [array.data]:
+Requires: If the deleter E is not a reference type,
+Aassignment of the deleter D from an rvalue
+DE shall not throw an exception.
+
+Otherwise the deleter E is a reference type,
+and assignment of the deleter D from an lvalue E shall not throw an exception.
+unique_ptr<U, E>::pointer shall be implicitly convertible to pointer.
+[Note: These requirements imply that T and U>
+are complete types. -- end note]
 
    
 
-
    
-
    23.2.1.5 array::c_array [array.c_array]
    
-    
    
-c_array_type & c_array() &;
-c_array_type && c_array() &&;
-const c_array_type & c_array() const &;
-
    
-
    
 
    
-Returns: elems.
+Effects: reset(u.release()) followed by
+an move assignment from u's deleter to this deleter
+std::forward<E>(u.get_deleter()).
+If either
+D or E is a reference type, then the referenced lvalue
+deleter participates in the move assignment.
 
    
-
    
 
 
    
+
    
 
 
 
-
    
-Change Zero sized arrays 23.3.1.6 [array.zero]:
-
    
-
-
    
 
-
    -2- ...
    
 
-
    
-The type c_array_type is unspecified for a zero-sized array.
-
    
 
+
    
+
    985. Allowing throwing move
    
+
    Section: 23.2.1 [container.requirements.general] Status: Open
+ Submitter: Rani Sharoni Opened: 2009-02-12  Last modified: 2009-10-20
    
+
    View other active issues in [container.requirements.general].
    
+
    View all other issues in [container.requirements.general].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
--3- The effect of calling c_array(), front(), or
-back() for a zero-sized array is implementation defined.
+Introduction
 
    
-
    
-
-
-
 
+
    This proposal is meant to resolve potential regression of the
+N2800
+draft, see
+next section, and to relax the requirements for containers of types with
+throwing move constructors.
    
 
+
    The basic problem is that some containers operations, like push_back,
+have a strong exception safety
+guarantee (i.e. no side effects upon exception) that are not achievable when
+throwing move constructors are used since there is no way to guarantee revert
+after partial move. For such operations the implementation can at most provide
+the basic guarantee (i.e. valid but unpredictable) as it does with multi
+copying operations (e.g. range insert).
    
 
-
    
-
    932. unique_ptr(pointer p) for pointer deleter types
    
-
    Section: 20.8.9.2.1 [unique.ptr.single.ctor] Status: Open
- Submitter: Howard Hinnant Opened: 2008-11-26  Last modified: 2009-07-27
    
-
    View other active issues in [unique.ptr.single.ctor].
    
-
    View all other issues in [unique.ptr.single.ctor].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    For example, vector<T>::push_back() (where T has a move
+constructor) might resize the vector and move the objects to the new underlying
+buffer. If move constructor throws it might
+not be possible to recover the throwing object or to move the old objects back to
+the original buffer.
    
 
-
    Addresses US 79
    
+
    The current draft is explicit by disallowing throwing move
+for some operations (e.g. vector<>::reserve) and not clear about other
+operations mentioned in 23.2.1 [container.requirements.general]/10
+(e.g. single element insert): it guarantees strong exception
+safety without explicitly disallowing a throwing move constructor.
+
    
 
 
    
-20.8.9.2.1 [unique.ptr.single.ctor]/5 no longer requires for D
-not to be a pointer type.  I believe this restriction was accidently removed
-when we relaxed the completeness reuqirements on T. The restriction
-needs to be put back in.  Otherwise we have a run time failure that could
-have been caught at compile time:
+Regression
 
    
 
-
    {
-unique_ptr<int, void(*)(void*)> p1(malloc(sizeof(int)));  // should not compile
-}  // p1.~unique_ptr() dereferences a null function pointer
-unique_ptr<int, void(*)(void*)> p2(malloc(sizeof(int)), free);  // ok
-
    
+
    This section only refers to cases in which the contained object
+is by itself a standard container.
    
 
-
    [
-Post Summit:
-]
    
+
    Move constructors of standard containers are allowed to throw and therefore
+existing operations are broken, compared with C++03, due to move optimization.
+(In fact existing implementations like Dinkumware are actually throwing).
    
 
+
    For example, vector< list<int> >::reserve yields
+undefined behavior since list<int>'s move constructor is allowed to throw.
+On the other hand, the same operation has strong exception safety guarantee in
+C++03.
    
 
-
    
-Recommend Tentatively Ready.
-
    
+
    There are few options to solve this regression:
    
 
-
    [
-2009-07 Frankfurt
-]
    
+
      
+
    1. 
+Disallow throwing move and throwing default constructor
+
      2. 
 
+
    2. 
+Disallow throwing move but disallowing usage after move
+
      3. 
 
-
      
-Moved from Tentatively Ready to Open only because the wording needs to be
-improved for enable_if type constraining, possibly following Robert's
-formula.
-
      
+
    3. 
+Special casing
+
      4. 
+
+
    4. 
+Disallow throwing move and making it optional
+
      5. 
+
+
    
+
+
    Option 1 is suggested by proposal
+N2815
+but it might not be applicable for existing implementations for which
+containers default constructors are throwing.
    
+
+
    Option 2 limits the usage significantly and it's error prone
+by allowing zombie objects that are nothing but destructible (e.g. no clear()
+is allowed after move). It also potentially complicates the implementation by
+introducing special state.
    
+
+
    Option 3 is possible, for example, using default
+construction and swap instead of move for standard containers case. The
+implementation is also free to provide special hidden operation for non
+throwing move without forcing the user the cope with the limitation of option-2
+when using the public move.
    
+
+
    Option 4 impact the efficiency in all use cases due to rare throwing move.
    
+
+
    The proposed wording will imply option 1 or 3 though option 2 is also
+achievable using more wording. I personally oppose to option 2 that has impact
+on usability.
    
+
+
    
+Relaxation for user types
+
    
+
+
    Disallowing throwing move constructors in general seems very restrictive
+since, for example, common implementation of move will be default construction
++ swap so move will throw if the
+default constructor will throw. This is currently the case with the Dinkumware
+implementation of node based containers (e.g. std::list)
+though this section doesn't refer to standard types.
    
+
+
    For throwing move constructors it seem that the implementation should have
+no problems to provide the basic guarantee instead of the strong one. It's
+better to allow throwing move constructors with basic guarantee than to
+disallow it silently (compile and run), via undefined behavior.
    
+
+
    There might still be cases in which the relaxation will break existing generic
+code that assumes the strong guarantee but it's broken either way given a
+throwing move constructor since this is not a preserving optimization. 
    
 
 
    [
-2009-07 Frankfurt:
+Batavia (2009-05):
 ]
    
 
-
 
    
 
    
-We need to consider whether some requirements in the Requires paragraphs
-of [unique.ptr] should instead be Remarks.
+Bjarne comments (referring to his draft paper):
+"I believe that my suggestion simply solves that.
+Thus, we don't need a throwing move."
 
    
 
    
-Leave Open. Howard to provide wording, and possibly demonstrate how this
-can be implemented using enable_if.
+Move to Open and recommend it be deferred until after the next
+Committee Draft is issued.
 
    
 
    
 
 
    [
-2009-07-27 Howard adds:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-
    
-The two constructors to which this issue applies are not easily constrained
-with enable_if as they are not templated:
-
    
+Should wait to get direction from Dave/Rani
+(N2983).
+
    
 
-
    unique_ptr();
-explicit unique_ptr(pointer p);
-
    
+
+
+
    Proposed resolution:
    
 
 
    
-To "SFINAE" these constructors away would take heroic effort such as specializing
-the entire unique_ptr class template on pointer deleter types.  There
-is insufficient motivation for such heroics.  Here is the expected and
-reasonable implementation for these constructors:
+23.2.1 [container.requirements.general]  paragraph 10 add footnote:
 
    
 
-
    unique_ptr()
-    : ptr_(pointer())
-    {
-        static_assert(!is_pointer<deleter_type>::value,
-            "unique_ptr constructed with null function pointer deleter");
-    }
-explicit unique_ptr(pointer p)
-    : ptr_(p)
-    {
-        static_assert(!is_pointer<deleter_type>::value,
-            "unique_ptr constructed with null function pointer deleter");
-    }
-
    
-
+
    
 
    
-I.e. just use static_assert to verify that the constructor is not
-instantiated with a function pointer for a deleter.  The compiler will automatically
-take care of issuing a diagnostic if the deleter is a reference type (uninitialized
-reference error).
+-10- Unless otherwise specified (see 23.1.4.1, 23.1.5.1, 23.2.2.3, and
+23.2.6.4) all container types defined in this Clause meet the following
+additional requirements:
 
    
+
      
+
    • ...
      • 
+
    
 
 
    
-In keeping with our discussions in Frankfurt, I'm moving this requirement on
-the implementation from the Requires paragraph to a Remarks paragraph.
+[Note: for compatibility with C++
+2003, when "no effect" is required, standard containers should not use the
+value_type's throwing move constructor when the contained object is by itself a
+standard container. -- end note]
 
    
 
 
    
 
+
    23.2.5.1 [unord.req.except] change paragraph 2 to say: 
    
 
-
-
    Proposed resolution:
    
+
    
 
    
-Change the description of the default constructor in 20.8.9.2.1 [unique.ptr.single.ctor]:
+-2- For unordered associative containers, if an exception is
+thrown by any operation other than the container's hash function from within an
+insert() function inserting a single element, the insert()
+function has no effect unless the exception is thrown by the contained
+object move constructor.
 
    
 
-
    unique_ptr();
-
    
-
    
 
    
--1- Requires: D shall be default constructible, and that construction
-shall not throw an exception. D shall 
-not be a reference type or pointer type (diagnostic required).
-
    
-
    ...
    
-Remarks: A diagnostic shall be emitted if this constructor is instantiated
-when D is a pointer type or reference type.
-
    
+-4- For unordered associative containers, if an exception is
+thrown from within a rehash() function other than by the container's hash
+function or comparison function, the rehash() function has no effect
+unless the exception is thrown by the contained
+object move constructor.
    
+
 
    
 
 
    
-Add  after 20.8.9.2.1 [unique.ptr.single.ctor]/8:
+23.3.2.3 [deque.modifiers] change paragraph 2 to say:
 
    
 
-
    unique_ptr(pointer p);
-
    
 
    
-
    ...
    
-Remarks: A diagnostic shall be emitted if this constructor is instantiated
-when D is a pointer type or reference type.
-
    
+-2- Remarks: If an exception is thrown other than by
+the copy constructor, move constructor
+or assignment operator of T
+there are no effects.
+If an exception is thrown by push_back() or emplace_back()
+function, that function has no effects unless the exception is thrown by
+the move constructor of T.
 
    
 
+
    
+23.3.2.3 [deque.modifiers] change paragraph 6 to say:
+
    
 
+
    
+-6- Throws: Nothing unless an exception is thrown by the copy
+constructor, move constructor or assignment operator of T.
+
    
 
+
    
+23.3.6.2 [vector.capacity] remove paragraph 2
+
    
 
+
    
+-2- Requires: If value_type has a move constructor,
+that constructor shall not throw any exceptions.
+
    
 
-
    
-
    933. Unique_ptr defect
    
-
    Section: 20.8.9.2.5 [unique.ptr.single.modifiers] Status: Open
- Submitter: Alisdair Meredith Opened: 2008-11-27  Last modified: 2009-05-23
    
-
    View all other issues in [unique.ptr.single.modifiers].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
 
    
-If we are supporting stateful deleters, we need an overload for
-reset that
-takes a deleter as well.
+23.3.6.2 [vector.capacity] paragraph 3 change to say:
 
    
 
-
    void reset( pointer p, deleter_type d);
-
    
+
    
+-3- Effects: A directive that informs a vector
+of a planned change in size, so
+that it can manage the storage allocation accordingly. After reserve(),
+capacity() is greater or equal to the argument of reserve
+if reallocation happens; and equal
+to the previous value of capacity()
+otherwise. Reallocation happens at this point if and only if the current
+capacity is less than the argument of reserve().
+If an exception is thrown, there are no effects
+unless the exception is thrown by the contained object move constructor.
+
    
 
 
    
-We probably need two overloads to support move-only deleters, and
-this
-sounds uncomfortably like the two constructors I have been ignoring
-for
-now...
+23.3.6.2 [vector.capacity] paragraph 12 change to say:
 
    
 
-
    [
-Batavia (2009-05):
-]
    
-
 
    
+-12- Requires: If value_type has a move constructor,
+that constructor shall not throw any exceptions.
+If an exception is thrown, there are no effects unless the exception is thrown by
+the contained object move constructor.
+
    
+
 
    
-Howard comments that we have the functionality via move-assigment.
+23.3.6.4 [vector.modifiers] change paragraph 1 to say:
 
    
+
+
    
+-1- Requires: If value_type has a move constructor,
+that constructor shall not throw any exceptions.
+Remarks: If an exception is thrown by push_back()
+or emplace_back() function, that function has no effect unless the
+exception is thrown by the move constructor of T.
+
    
+
 
    
-Move to Open.
+23.3.6.4 [vector.modifiers] change paragraph 2 to say:
 
    
-
    
 
+
    
+-2- Remarks: Causes reallocation if the new size is greater than
+the old capacity. If no reallocation happens, all the iterators and
+references before the insertion point remain valid. If an exception is
+thrown other than by the copy constructor, move constructor
+or assignment operator of T or by any InputIterator
+operation there are no effects.
+
    
 
-
    Proposed resolution:
    
 
    
+23.3.6.4 [vector.modifiers] change paragraph 6 to say:
 
    
 
+
    
+-6- Throws: Nothing unless an exception is thrown by the copy
+constructor, move constructor or assignment operator of T.
+
    
 
 
 
 
-
    
-
    934. duration is missing operator%
    
-
    Section: 20.9.3 [time.duration] Status: Ready
- Submitter: Terry Golubiewski Opened: 2008-11-30  Last modified: 2009-07-27
    
-
    View other active issues in [time.duration].
    
-
    View all other issues in [time.duration].
    
-
    View all issues with Ready status.
    
-
    Discussion:
    
-
-
    Addresses US 81
    
 
-
    
-duration is missing operator%.  This operator is convenient
-for computing where in a time frame a given duration lies.  A
-motivating example is converting a duration into a "broken-down"
-time duration such as hours::minutes::seconds:
-
    
 
-
    class ClockTime
-{
-    typedef std::chrono::hours hours;
-    typedef std::chrono::minutes minutes;
-    typedef std::chrono::seconds seconds;
-public:
-    hours hours_;
-    minutes minutes_;
-    seconds seconds_;
-
-    template <class Rep, class Period>
-      explicit ClockTime(const std::chrono::duration<Rep, Period>& d)
-        : hours_  (std::chrono::duration_cast<hours>  (d)),
-          minutes_(std::chrono::duration_cast<minutes>(d % hours(1))),
-          seconds_(std::chrono::duration_cast<seconds>(d % minutes(1)))
-          {}
-};
-
    
+
    
+
    987. reference_wrapper and function types
    
+
    Section: 20.7.5 [refwrap] Status: Tentatively Ready
+ Submitter: Howard Hinnant Opened: 2009-02-18  Last modified: 2009-10-26
    
+
    View all other issues in [refwrap].
    
+
    View all issues with Tentatively Ready status.
    
+
    Discussion:
    
+
    
+The synopsis in 20.7.5 [refwrap] says:
+
    
 
-
    [
-Summit:
-]
    
+
    template <ObjectType T> class reference_wrapper
+...
+
    
 
+
    
+And then paragraph 3 says:
+
    
 
 
    
-Agree except that there is a typo in the proposed resolution. The member
-operators should be operator%=.
+
    
+The template instantiation reference_wrapper<T> shall be
+derived from std::unary_function<T1, R> only if the type
+T is any of the following:
+
    
+
+
      
+
    • 
+a function type or a pointer to function type taking one argument of
+type T1 and returning R
+
      • 
+
    
 
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    
+But function types are not ObjectTypes.
+
    
 
-
    
-We agree with the proposed resolution.
-Move to Tentatively Ready.
-
    
+
    
+Paragraph 4 contains the same contradiction.
+
    
 
 
    [
-2009-07 Frankfurt
+Post Summit:
 ]
    
 
 
 
    
-Moved from Tentatively Ready to Open only because the wording needs to be
-improved for enable_if type constraining, possibly following Robert's
-formula.
+
    
+Jens: restricted reference to ObjectType
+
    
+
    
+Recommend Review.
+
    
 
    
 
 
    [
-2009-07 Frankfurt:
+Post Summit, Peter adds:
 ]
    
 
 
 
    
 
    
-Howard to open a separate issue (1177) to handle the removal of member
-functions from overload sets, provide wording, and possibly demonstrate
-how this can be implemented using enable_if (see 947).
+In https://svn.boost.org/trac/boost/ticket/1846
+however Eric Niebler makes the very reasonable point that reference_wrapper<F>,
+where F is a function type, represents a reference to a function,
+a legitimate entity. So boost::ref was changed to allow it.
 
    
 
    
-Move to Ready.
+https://svn.boost.org/trac/boost/browser/trunk/libs/bind/test/ref_fn_test.cpp
+
    
+
    
+Therefore, I believe an alternative proposed resolution for issue 987 could simply
+allow reference_wrapper to be used with function types.
 
    
 
    
 
+
    [
+Post Summit, Howard adds:
+]
    
 
 
-
    Proposed resolution:
    
+
    
 
    
-Add to the synopsis in 20.9 [time]:
+I agree with Peter (and Eric).  I got this one wrong on my first try.  Here
+is code that demonstrates how easy (and useful) it is to instantiate
+reference_wrapper with a function type:
 
    
 
-
    template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
-  operator%(const duration<Rep1, Period>& d, const Rep2& s);
-template <class Rep1, class Period1, class Rep2, class Period2>
-  typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
-  operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
    #include <functional>
+
+template <class F>
+void test(F f);
+
+void f() {}
+
+int main()
+{
+    test(std::ref(f));
+}
 
    
 
 
    
-Add to the synopsis of duration in 20.9.3 [time.duration]:
+Output (link time error shows type of reference_wrapper instantiated
+with function type):
 
    
 
-
    template <class Rep, class Period = ratio<1>>
-class duration {
-public:
-  ...
-  duration& operator%=(const rep& rhs);
-  duration& operator%=(const duration& d);
-  ...
-};
+
    Undefined symbols:
+  "void test<std::reference_wrapper<void ()()> >(std::reference_wrapper<void ()()>)",...
 
    
 
 
    
-Add to 20.9.3.3 [time.duration.arithmetic]:
+I've taken the liberty of changing the proposed wording to allow function types
+and set to Open.  I'll also freely admit that I'm not positive ReferentType
+is the correct concept.
 
    
 
-
    
-
    duration& operator%=(const rep& rhs);
-
    
-
    
-
    
-Effects: rep_ %= rhs.
-
    
-
    
-Returns: *this.
-
    
 
    
 
-
    duration& operator%=(const duration& d);
-
    
+
+
+
    [
+Batavia (2009-05):
+]
    
+
 
    
 
    
-Effects: rep_ %= d.count().
+Howard observed that FunctionType,
+a concept not (yet?) in the Working Paper,
+is likely the correct constraint to be applied.
+However, the proposed resolution provides an adequate approximation.
 
    
 
    
-Returns: *this.
+Move to Review.
 
    
 
    
-
    
 
-
    
-Add to 20.9.3.5 [time.duration.nonmember]:
-
    
+
    [
+2009-05-23 Alisdair adds:
+]
    
 
-
    
 
-
    template <class Rep1, class Period, class Rep2>
-  duration<typename common_type<Rep1, Rep2>::type, Period>
-  operator%(const duration<Rep1, Period>& d, const Rep2& s);
-
    
 
    
 
    
-Requires: Rep2 shall be implicitly convertible to CR(Rep1, Rep2) and
-Rep2 shall not be an instantiation of duration. Diagnostic required.
+By constraining to PointeeType we rule out the ability for T to be a
+reference, and call in reference-collapsing.  I'm not sure if this is
+correct and intended, but would like to be sure the case was considered.
 
    
 
    
-Returns: duration<CR, Period>(d) %= s.
+Is dis-allowing reference types and the
+implied reference collapsing the intended result?
 
    
 
    
 
-
    template <class Rep1, class Period1, class Rep2, class Period2>
-  typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
-  operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-
    
+
    [
+2009-07 Frankfurt
+]
    
+
+
 
    
-
    
-Returns: common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type(lhs) %= rhs.
-
    
+Moved from Review to Open only because the wording needs to be
+tweaked for concepts removal.
 
    
 
-
    
+
    [
+2009-10-14 Daniel provided de-conceptified wording.
+]
    
+
 
+
    [
+2009-10 post-Santa Cruz:
+]
    
 
 
+
    
+Move to Tentatively Ready.
+
    
 
 
 
-
    
-
    935. clock error handling needs to be specified
    
-
    Section: 20.9.5 [time.clock] Status: Open
- Submitter: Beman Dawes Opened: 2008-11-24  Last modified: 2009-05-23
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    Proposed resolution:
    
 
    
-Each of the three clocks specified in Clocks 20.9.5 [time.clock]
-provides the member function:
+Change 20.7.5 [refwrap]/1 as indicated:
 
    
 
-
    static time_point now();
-
    
+
    
+reference_wrapper<T> is a CopyConstructible and
+CopyAssignable wrapper around a
+reference to an object or function of type T.
+
    
+
+
 
+
+
+
    Rationale:
    
 
    
-The semantics specified by Clock requirements 20.9.1 [time.clock.req]
-make no mention of error handling. Thus the function may throw bad_alloc
-or an implementation-defined exception (17.6.4.10 [res.on.exception.handling]
-paragraph 4).
+a) The occurrence of T& in the function signature auto-implies
+std::ReferentType,
+this is due to  [temp.req.impl]/4 bullet 4
 
    
-
 
    
-Some implementations of these functions on POSIX, Windows, and
-presumably on other operating systems, may fail in ways only detectable
-at runtime. Some failures on Windows are due to supporting chipset
-errata and can even occur after successful calls to a clock's now()
-function.
+b) The occurrence of the constrained template reference_wrapper<T> in
+the remaining
+signatures lets kick in  [temp.req.impl]/4 bullet 1 and adds *all* requirements of
+this template. But we need to add at least *one* requirement (and it
+was an arbitrary,
+but natural decision to require std::PointeeType here) to *activate*
+this. If we hadn't done
+this, we were in unconstrained mode!
 
    
 
+
+
+
+
+
    
+
    996. Move operation not well specified
    
+
    Section: 17 [library] Status: Open
+ Submitter: David Abrahams Opened: 2009-03-06  Last modified: 2009-05-23
    
+
    View other active issues in [library].
    
+
    View all other issues in [library].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-These functions are used in cases where exceptions are not appropriate
-or where the specifics of the exception or cause of error need to be
-available to the user. See
-N2828,
-Library Support for hybrid error
-handling (Rev 1), for more specific discussion of use cases. Thus some change in
-the interface of now is required.
+There are lots of places in the standard where we talk about "the move
+constructor" but where we mean "the move operation," i.e.  T( move( x ) ).
 
    
-
 
    
-The proposed resolution has been implemented in the Boost version of the
-chrono library. No problems were encountered.
+We also don't account for whether that operation modifies x or not, and
+we need to.
 
    
 
 
    [
@@ -18326,620 +15287,508 @@ Batavia (2009-05):
 ]
    
 
 
    
-
    
-We recommend this issue be deferred until the next Committee Draft
-has been issued and the prerequisite paper has been accepted.
-
    
-
    
-Move to Open.
-
    
+Move to Open, pending proposed wording from Dave for further
+review.
 
    
 
 
 
    Proposed resolution:
    
 
    
-Accept the proposed wording of
-N2828,
-Library Support for hybrid error handling (Rev 1).
-
    
-
-
    
-Change Clock requirements 20.9.1 [time.clock.req] as indicated:
-
    
-
-
    
-
    
--2- In Table 55 C1 and C2 denote clock types. t1 and
-t2 are values returned by C1::now() where the call 
-returning t1 happens before (1.10) the call returning t2 and
-both of these calls happen before C1::time_point::max().
-ec denotes an object of type error_code 
-(19.5.2.2 [syserr.errcode.overview]).
 
    
 
-
-
-
-
-
 
-
-
-
-
-
 
-
-
-
-
-
 
-
-
-
-
-
-
    Table 55 -- Clock requirements
    ExpressionReturn typeOperational semantics
    .........
    C1::now()C1::time_pointReturns a time_point object representing the current point in time.
-
    C1::now(ec)C1::time_pointReturns a time_point object representing the current point in time.
-
    
-
    
 
+
    
+
    999. Taking the address of a function
    
+
    Section: 20.8.13 [specialized.algorithms] Status: Tentatively Ready
+ Submitter: Peter Dimov Opened: 2009-03-09  Last modified: 2009-10-26
    
+
    View all other issues in [specialized.algorithms].
    
+
    View all issues with Tentatively Ready status.
    
+
    Discussion:
    
 
    
-Change Class system_clock 20.9.5.1 [time.clock.system] as indicated:
+The same fix (reference 987) may be applied to addressof, which is also constrained to
+ObjectType. (That was why boost::ref didn't work with functions - it
+tried to apply boost::addressof and the reinterpret_cast<char&>
+implementation of addressof failed.)
 
    
 
-
    static time_point now(error_code& ec=throws());
-
    
 
-
    
-Change Class monotonic_clock 20.9.5.2 [time.clock.monotonic] as indicated:
-
    
 
-
    static time_point now(error_code& ec=throws());
-
    
+
    [
+Batavia (2009-05):
+]
    
 
+
    
+
    
+We agree.
+
    
 
    
-Change Class high_resolution_clock 20.9.5.3 [time.clock.hires] as indicated:
+Move to Tentatively Ready.
 
    
+
    
 
-
    static time_point now(error_code& ec=throws());
-
    
+
    [
+2009-07 Frankfurt
+]
    
 
 
+
    
+Moved from Tentatively Ready to Open only because the wording needs to be
+tweaked for concepts removal.
+
    
 
+
    [
+2009-10-10 Daniel updates wording to concept-free.
+]
    
 
 
+
    [
+2009-10 post-Santa Cruz:
+]
    
+
+
+
    
+Move to Tentatively Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
    [
+The resolution assumes that addressof is reintroduced as described in
+n2946
+]
    
 
-
    
-
    936. Mutex type overspecified
    
-
    Section: 30.4.1 [thread.mutex.requirements] Status: Open
- Submitter: Pete Becker Opened: 2008-12-05  Last modified: 2009-03-22
    
-
    View other active issues in [thread.mutex.requirements].
    
-
    View all other issues in [thread.mutex.requirements].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-30.4.1 [thread.mutex.requirements] describes the requirements for a type to be
-a "Mutex type". A Mutex type can be used as the template argument for
-the Lock type that's passed to condition_variable_any::wait (although
-Lock seems like the wrong name here, since Lock is given a different
-formal meaning in 30.4.3 [thread.lock]) and, although the WD doesn't quite say
-so, as the template argument for lock_guard and unique_lock.
-
    
 
 
    
-The requirements for a Mutex type include:
+In 20.8.13 [specialized.algorithms] change as described:
 
    
 
-
      
-
    • 
-m.lock() shall be well-formed and have [described] semantics, including a return type of void.
-
      • 
-
    • 
-m.try_lock() shall be well-formed and have [described] semantics, including a return type of bool.
-
      • 
-
    • 
-m.unlock() shall be well-formed and have [described] semantics, including a return type of void.
-
      • 
-
    
+
    template <class T> T* addressof(T& r);
+
    
+
    
+Returns: The actual address of the object or function
+referenced by r, even in the
+presence of an overloaded operator&.
+
    
+
    
 
+
+
+
+
    Rationale:
    
 
    
-Also, a Mutex type "shall not be copyable nor movable".
+a) The occurrence of T& in the function signature auto-implies
+std::ReferentType,
+this is due to  [temp.req.impl]/4 bullet 4
 
    
 
+
+
+
+
+
    
+
    1008. nested_exception wording unclear
    
+
    Section: 18.8.6 [except.nested] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-22
    
+
    View other active issues in [except.nested].
    
+
    View all other issues in [except.nested].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
+
+
    Addresses JP 31
    
+
 
    
-The latter requirement seems completely irrelevant, and the three
-requirements on return types are tighter than they need to be. For
-example, there's no reason that lock_guard can't be instantiated with a
-type that's copyable. The rule is, in fact, that lock_guard, etc. won't
-try to copy objects of that type. That's a constraint on locks, not on
-mutexes. Similarly, the requirements for void return types are
-unnecessary; the rule is, in fact, that lock_guard, etc. won't use any
-returned value. And with the return type of bool, the requirement should
-be that the return type is convertible to bool.
+It is difficult to understand in which case nested_exception is applied.
 
    
 
 
    [
 Summit:
 ]
    
 
-
+ 
 
    
-
    
-Move to open. Related to conceptualization and should probably be tackled as part of that.
-
    
-
      
-
    • 
-The intention is not only to place a constraint on what types such as
-lock_guard may do with mutex types, but on what any code, including user
-code, may do with mutex types. Thus the constraints as they are apply to
-the mutex types themselves, not the current users of mutex types in the
-standard.
-
      • 
-
    • 
-This is a low priority issue; the wording as it is may be overly
-restrictive but this may not be a real issue.
-
      • 
-
    
+Alisdair will add an example in an update to
+N2619.
 
    
 
 
    [
-Post Summit Anthony adds:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-
    
-Section 30.4.1 [thread.mutex.requirements] conflates the
-requirements on a generic Mutex type (including user-supplied mutexes)
-with the requirements placed on the standard-supplied mutex types in an
-attempt to group everything together and save space.
-
    
-
    
-When applying concepts to chapter 30, I suggest that the concepts
-Lockable and TimedLockable embody the requirements for
-*use* of a mutex type as required by
-unique_lock/lock_guard/condition_variable_any. These should be
-relaxed as Pete describes in the issue. The existing words in 30.4.1 [thread.mutex.requirements] are requirements on all of
-std::mutex, std::timed_mutex,
-std::recursive_mutex and std::recursive_timed_mutex,
-and should be rephrased as such.
-
    
+It doesn't appear that N2619 really addresses this. Alisdair to propose wording.
 
    
 
 
 
 
    Proposed resolution:
    
-
    
-
    
 
 
 
 
 
 
    
-
    939. Problem with std::identity and reference-to-temporaries
    
-
    Section: 20.7.6 [identity.operation] Status: Open
- Submitter: Alisdair Meredith Opened: 2008-12-11  Last modified: 2009-07-30
    
-
    View all issues with Open status.
    
+
    1011. next/prev wrong iterator type
    
+
    Section: 24.4.4 [iterator.operations] Status: Ready
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-22
    
+
    View other active issues in [iterator.operations].
    
+
    View all other issues in [iterator.operations].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
+
+
    Addresses UK 271
    
+
 
    
-std::identity takes an argument of type T const &
-and returns a result of T const &.
-
    
-
    
-Unfortunately, this signature will accept a value of type other than T that
-is convertible-to-T, and then return a reference to the dead temporary.  The
-constraint in the concepts version simply protects against returning
-reference-to-void.
-
    
-
    
-Solutions:
+next/prev return an incremented iterator without changing the value of
+the original iterator. However, even this may invalidate an
+InputIterator. A ForwardIterator is required to guarantee the
+'multipass' property.
 
    
+
+
    [
+Batavia (2009-05):
+]
    
+
 
    
-
    
-i/  Return-by-value, potentially slicing bases and rejecting non-copyable
-types
-
    
-
    
-ii/ Provide an additional overload:
-
    
-
    template< typename T >
-template operator( U & ) = delete;
-
    
-
    
-This seems closer on intent, but moves beyond the original motivation for
-the operator, which is compatibility with existing (non-standard)
-implementations.
-
    
-
    
-iii/ Remove the operator() overload.  This restores the original definition
-of the identity, although now effectively a type_trait rather than part of
-the perfect forwarding protocol.
-
    
-
    
-iv/ Remove std::identity completely; its original reason to exist is
-replaced with the IdentityOf concept.
-
    
+We agree with the proposed resolution.
+Move to Tentatively Ready.
 
    
-
    
-My own preference is somewhere between (ii) and (iii) - although I stumbled
-over the issue with a specific application hoping for resolution (i)!
-
    
 
 
    [
-Batavia (2009-05):
+2009-07 Frankfurt
 ]
    
 
+
 
    
-
    
-We dislike options i and iii, and option ii seems like overkill.
-If we remove it (option iv), implementers can still provide it under a
-different name.
-
    
-
    
-Move to Open pending wording (from Alisdair) for option iv.
-
    
+Moved from Tentatively Ready to Open only because the wording needs to be
+tweaked for concepts removal.
 
    
 
 
    [
-2009-05-23 Alisdair provided wording for option iv.
+2009-10-14 Daniel provided de-conceptified wording.
 ]
    
 
 
 
    [
-2009-07-20 Alisdair adds:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
+Moved to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
+
+
      
+
    1. 
 
      
-I'm not sure why this issue was not discussed at Frankfurt (or I missed
-the discussion) but the rationale is now fundamentally flawed.  With the
-removal of concepts, std::identity again becomes an important library
-type so we cannot simply remove it.
+Change header <iterator> synopsis 24.3 [iterator.synopsis] as indicated:
 
      
+
+
      // 24.4.4, iterator operations:
+...
+template <class InputForwardIterator>
+  InputForwardIterator
+  next(InputForwardIterator x, typename std::iterator_traits<InputForwardIterator>::difference_type n = 1);
+
      
+
      2. 
+
+
    2. 
 
      
-At that point, we need to pick one of the other suggested resolutions,
-but have no guidance at the moment.
+Change 24.4.4 [iterator.operations] before p.6 as indicated:
 
      
-
    
 
-
    [
-2009-07-20 Howard adds:
-]
    
+
    template <class InputForwardIterator>
+  InputForwardIterator
+  next(InputForwardIterator x, typename std::iterator_traits<InputForwardIterator>::difference_type n = 1);
+
    
+
+
 
 
-
    
+
+
+
+
+
    
+
    1030. Response to JP 44
    
+
    Section: 20.8.15.5 [util.smartptr.shared.atomic] Status: Ready
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-23
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
+
+
    Addresses JP 44
    
+
 
    
-I believe the rationale for not addressing this issue in Frankfurt was that it did
-not address a national body comment.
+The 1st parameter p and 2nd parameter v is now
+shared_ptr<T>*.
 
    
 
    
-I also believe that removal of identity is still a practical option as
-my latest reformulation of forward, which is due to comments suggested
-at Summit, no longer uses identity. :-)
+It should be shared_ptr<T>&, or if these are
+shared_ptr<T>* then add the "p shall not be a
+null pointer" at the requires.
 
    
 
-
    template <class T, class U,
-    class = typename enable_if
-            <
-                !is_lvalue_reference<T>::value || 
-                 is_lvalue_reference<T>::value &&
-                 is_lvalue_reference<U>::value
-            >::type,
-    class = typename enable_if
-            <
-                is_same<typename remove_all<T>::type,
-                        typename remove_all<U>::type>::value
-            >::type>
-inline
-T&&
-forward(U&& t)
-{
-    return static_cast<T&&>(t);
-
-}
-
    
-
 
    [
-The above code assumes acceptance of 1120 for the definition of
-remove_all.  This is just to make the syntax a little more palatable.
-Without this trait the above is still very implementable.
+Summit:
 ]
    
 
 
+
    
+Agree. All of the functions need a requirement that p (or
+v) is a pointer to a valid object.
 
    
 
+
    [
+2009-07 post-Frankfurt:
+]
    
+
+
+
    
 
    
-Paper with rationale is on the way ... really, I promise this time! ;-)
+Lawrence explained that these signatures match the regular atomics. The
+regular atomics must not use references because these signatures are
+shared with C. The decision to pass shared_ptrs by pointer rather than
+by reference was deliberate and was motivated by the principle of least
+surprise.
+
    
+
    
+Lawrence to write wording that requires that the pointers not be null.
 
    
 
    
 
 
    [
-2009-07-30 Daniel adds:  See 823 for an alternative resolution.
+2009-09-20 Lawrence provided wording:
 ]
    
 
 
-
-
    Proposed resolution:
    
+
    
+
    
+The parameter types for atomic shared pointer access
+were deliberately chosen to be pointers
+to match the corresponding parameters of the atomics chapter.
+Those in turn were deliberately chosen
+to match C functions,
+which do not have reference parameters.
+
    
 
    
-Strike 20.2.1 [concept.transform] p3:
+We adopt the second suggestion,
+to require that such pointers not be null.
 
    
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
 
 
    
--4- Note: concept form of the identity type metafunction (20.7.6).
+Moved to Ready.
 
    
 
-
    
-Strike from 20.7 [function.objects] p2:
-
    
 
-
    // 20.7.6, identity operation:
-template <IdentityOf T> struct identity;
-
    
 
+
    Proposed resolution:
    
 
    
-Remove 20.7.6 [identity.operation] (whole subclause):
+In section "shared_ptr atomic access"
+20.8.15.5 [util.smartptr.shared.atomic], add to each function the
+following clause.
 
    
-
-
    
-
    template <IdentityOf T> struct identity {
-  typedef T type;
-
-  requires ReferentType<T>
-     const T& operator()(const T& x) const;
-};
-
-requires ReferentType<T>
-  const T& operator()(const T& x) const;
-
    
-
    
--1-  Returns: x
-
    
-
    
-
+
    
+Requires: p shall not be null.
+
    
 
 
 
 
 
 
    
-
    940. std::distance
    
-
    Section: 24.4 [iterator.operations] Status: Open
- Submitter: Thomas Opened: 2008-12-14  Last modified: 2009-07-18
    
-
    View other active issues in [iterator.operations].
    
-
    View all other issues in [iterator.operations].
    
+
    1033. thread::join() effects?
    
+
    Section: 30.3.1.5 [thread.thread.member] Status: Open
+ Submitter: Alberto Ganesh Barbati Opened: 2009-03-12  Last modified: 2009-05-23
    
+
    View other active issues in [thread.thread.member].
    
+
    View all other issues in [thread.thread.member].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
 
-
    Addresses UK 270
    
-
-
    
-Regarding the std::distance - function, 24.4 [iterator.operations]
-/ 4 says:
-
    
-
    
-Returns the
-number of increments or decrements needed to get from first to last.
-
    
-
    
-This sentence is completely silent about the sign of the return value.
-24.4 [iterator.operations] / 1 gives more information about the
-underlying operations, but
-again no inferences about the sign can be made.
-Strictly speaking, that is taking that sentence literally, I think this
-sentence even implies a positive return value in all cases, as the
-number of increments or decrements is clearly a ratio scale variable,
-with a natural zero bound.
-
    
-
    
-Practically speaking, my implementations did what common sense and
-knowledge based on pointer arithmetic forecasts, namely a positive sign
-for increments (that is, going from first to last by operator++), and a
-negative sign for decrements (going from first to last by operator--).
-
    
-
    
-Here are my two questions:
-
    
 
    
-First, is that paragraph supposed to be interpreted in the way what I
-called 'common sense', that is negative sign for decrements ? I am
-fairly sure that's the supposed behavior, but a double-check here in
-this group can't hurt.
+While looking at thread::join() I think I spotted a couple of
+possible defects in the specifications. I could not find a previous
+issue or NB comment about that, but I might have missed it.
 
    
+
 
    
-Second, is the present wording (2003 standard version - no idea about
-the draft for the upcoming standard) worth an edit to make it a bit more
-sensible, to mention the sign of the return value explicitly ?
+The postconditions clause for thread::join() is:
 
    
 
-
    [
-Daniel adds:
-]
    
-
-
 
    
-
    
-My first thought was that resolution 204 would already cover the
-issue report, but it seems that current normative wording is in
-contradiction to that resolution:
-
    
+Postconditions: If join() throws an exception, the value
+returned by get_id() is unchanged. Otherwise, get_id() == id().
+
    
 
 
    
-Referring to
-N2798,
-24.4 [iterator.operations]/ p.4 says:
+and the throws clause is:
 
    
 
 
    
-Effects: Returns the number of increments or decrements needed to get
-from first to last.
+Throws: std::system_error when the postconditions cannot be achieved.
 
    
 
 
    
-IMO the part " or decrements" is in contradiction to p. 5 which says
+Now... how could the postconditions not be achieved?
+It's just a matter of resetting the value of get_id() or leave it
+unchanged! I bet we can always do that. Moreover, it's a chicken-and-egg
+problem: in order to decide whether to throw or not I depend on the
+postconditions, but the postconditions are different in the two cases.
 
    
 
-
    
-Requires: last shall be reachable from first.
-
    
-
 
    
-because "reachable" is defined in 24.2 [iterator.concepts]/7 as
+I believe the throws clause should be:
 
    
 
 
    
-An iterator j is called reachable from an iterator i if and only if
-there is a finite
-sequence of applications of the expression ++i that makes i == j.[..]
+Throws: std::system_error when the effects or postconditions
+cannot be achieved.
 
    
 
 
    
-Here is wording that would be consistent with this definition of "reachable":
+as it is in detach(), or, even better, as the postcondition is
+trivially satisfiable and to remove the circular dependency:
 
    
 
-
    
-Change 24.4 [iterator.operations] p4 as follows:
-
    
 
 
    
-Effects: Returns the number of increments or decrements
-needed to get from first to last.
-
    
-
+Throws: std::system_error if the effects cannot be achieved.
 
    
 
 
    
-Thomas adds more discussion and an alternative view point
-here.
+Problem is that... ehm... join() has no "Effects" clause. Is that intentional?
 
    
 
 
    [
-Summit:
+See the thread starting at c++std-lib-23204 for more discussion.
 ]
    
 
 
-
    
-The proposed wording below was verbally agreed to.  Howard provided.
-
    
-
 
    [
 Batavia (2009-05):
 ]
    
 
 
    
 
    
-Pete reports that a recent similar change has been made
-for the advance() function.
+Pete believes there may be some more general language (in frontmatter)
+that can address this and related issues such as 962.
 
    
 
    
-We agree with the proposed resolution.
-Move to Tentatively Ready.
+Move to Open.
 
    
 
    
 
-
    [
-2009-07 Frankfurt
-]
    
 
+
    Proposed resolution:
    
 
-
    
-Moved from Tentatively Ready to Open only because the wording needs to be
-tweaked for concepts removal.
-
    
 
-
    [
-2009-07 Frankfurt:
-]
    
 
 
-
    
-Leave Open pending arrival of a post-Concepts WD.
-
    
 
+
    
+
    1034. Response to UK 222
    
+
    Section: 23.2.1 [container.requirements.general] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-20
    
+
    View other active issues in [container.requirements.general].
    
+
    View all other issues in [container.requirements.general].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
+
    Addresses UK 222
    
 
-
    Proposed resolution:
    
 
    
-Change 24.4 [iterator.operations]:
+It is not clear what purpose the Requirement tables serve in the
+Containers clause. Are they the definition of a library Container? Or
+simply a conventient shorthand to factor common semantics into a single
+place, simplifying the description of each subsequent container? This
+becomes an issue for 'containers' like array, which does not meet the
+default-construct-to-empty requirement, or forward_list which does not
+support the size operation. Are these components no longer containers?
+Does that mean the remaining requirements don't apply? Or are these
+contradictions that need fixing, despite being a clear design decision?
 
    
 
-
    
-
    template <InputIterator Iter>
-  Iter::difference_type
-  distance(Iter first, Iter last);
-template <RandomAccessIterator Iter>
-  Iter::difference_type distance(Iter first, Iter last);
-
    
-
-
    
 
    
--4- Effects: Returns the number of increments or decrements
-needed to get from first to last.
+Recommend:
 
    
+
 
    
--5- Requires: last shall be reachable from first.
+Clarify all the tables in 23.2 [container.requirements] are
+there as a convenience for documentation, rather than a strict set of
+requirements. Containers should be allowed to relax specific
+requirements if they call attention to them in their documentation. The
+introductory text for array should be expanded to mention a
+default constructed array is not empty, and
+forward_list introduction should mention it does not provide
+the required size operation as it cannot be implemented
+efficiently.
 
    
+
+
    [
+Summit:
+]
    
+
+
+
    
+Agree in principle.
 
    
 
-
    template <RandomAccessIterator Iter>
-  Iter::difference_type distance(Iter first, Iter last);
-
    
+
    [
+2009-07 post-Frankfurt:
+]
    
+
 
 
    
-
    
--6- Effects: Returns the number of increments or decrements
-needed to get from first to last.
-
    
-
    
--7- Requires: last shall be reachable from first
-or first shall be reachable from last.
-
    
+We agree in principle, but we have a timetable. This group feels that
+the issue should be closed as NAD unless a proposed resolution is
+submitted prior to the March 2010 meeting.
 
    
 
+
    [
+2009-10 Santa Cruz:
+]
    
+
 
+
    
+Looked at this and still intend to close as NAD in March
+2010 unless there is proposed wording that we like.
 
    
 
 
 
+
    Proposed resolution:
    
+
+
 
 
 
 
    
-
    944. atomic<bool> derive from atomic_bool?
    
-
    Section: 29.5.3 [atomics.types.generic] Status: Open
- Submitter: Holger Grund Opened: 2008-12-19  Last modified: 2009-03-22
    
-
    View all other issues in [atomics.types.generic].
    
-
    View all issues with Open status.
    
+
    1052. Response to UK 281
    
+
    Section: 24.5.1.3.5 [reverse.iter.opref] Status: Ready
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-22
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
    
-I think it's fairly obvious that atomic<bool> is supposed to be derived
-from atomic_bool (and otherwise follow the atomic<integral> interface),
-though I think the current wording doesn't support this. I raised this
-point along with atomic<floating-point> privately with Herb and I seem
-to recall it came up in the resulting discussion on this list. However,
-I don't see anything on the current libs issue list mentioning this
-problem.
-
    
-
-
    
-29.5.3 [atomics.types.generic]/3 reads
-
    
 
-
    
-There are full specializations over the integral types on the atomic
-class template. For each integral type integral in the second column of
-table 121 or table 122, the specialization atomic<integral> shall be
-publicly derived from the corresponding atomic integral type in the
-first column of the table. These specializations shall have trivial
-default constructors and trivial destructors.
-
    
+
    Addresses UK 281
    
 
 
    
-Table 121 does not include (atomic_bool, bool),
-so that this should probably be mentioned explicitly in the quoted paragraph.
+The current specification for return value for reverse_iterator::operator->
+will always be a true pointer type, but reverse_iterator supports proxy
+iterators where the pointer type may be some kind of 'smart pointer'.
 
    
 
 
    [
@@ -18948,308 +15797,323 @@ Summit:
 
 
 
    
-Move to open. Lawrence will draft a proposed resolution. Also, ask
-Howard to fix the title.
-
    
-
-
    [
-Post Summit Anthony provided proposed wording.
-]
    
-
-
-
-
    Proposed resolution:
    
 
    
-Replace paragraph 3 in 29.5.3 [atomics.types.generic] with
+move_iterator avoids this problem by returning a value of the wrapped
+Iterator type.
+study group formed to come up with a suggested resolution.
 
    
-
-
    
--3- There are full specializations over the integral types on the atomic
-class template. For each integral type integral in the second column of
-table 121 or table 122, the specialization atomic<integral> shall be
-publicly derived from the corresponding atomic integral type in the first
-column of the table.
-In addition, the specialization atomic<bool>
-shall be publicly derived from atomic_bool.
-These specializations shall have trivial default
-constructors and trivial destructors.
-
    
-
-
-
-
-
-
    
-
    947. duration arithmetic: contradictory requirements
    
-
    Section: 20.9.3.5 [time.duration.nonmember] Status: Open
- Submitter: Pete Becker Opened: 2008-12-20  Last modified: 2009-07-27
    
-
    View all other issues in [time.duration.nonmember].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
 
    
-In 20.9.3.5 [time.duration.nonmember], paragraph 8 says that calling
-dur / rep
-when rep is an instantiation of duration requires a diagnostic.
-That's followed by an operator/ that takes two durations.
-So dur1 / dur2 is legal under the second version,
-but requires a diagnostic under the first.
+move_iterator solution shown in proposed wording.
 
    
+
    
 
 
    [
-Howard adds:
+2009-07 post-Frankfurt:
 ]
    
 
 
 
    
-Please see the thread starting with c++std-lib-22980 for more information.
+Howard to deconceptize. Move to Review after that happens.
 
    
 
 
    [
-Batavia (2009-05):
+2009-08-01 Howard deconceptized:
 ]
    
 
+
 
    
-Move to Open, pending proposed wording (and preferably an implementation).
 
    
 
 
    [
-2009-07-27 Howard adds:
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
 
    
-I've addressed this issue under the proposed wording for 1177 which
-cleans up several places under 20.9.3 [time.duration] which used the
-phrase "diagnostic required".
+We can't think of any reason we can't just define reverse
+iterator's pointer types to be the same as the underlying iterator's
+pointer type, and get it by calling the right arrow directly.
 
    
 
    
-For clarity's sake, here is an example implementation of the constrained operator/:
+Here is the proposed wording that was replaced:
 
    
+
    template <class Iterator> 
+class reverse_iterator { 
+  ...
+  typedef typename iterator_traits<Iterator>::pointer pointer;
+
    
 
-
    template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
-struct __duration_divide_result
-{
-};
-
-template <class _Duration, class _Rep2,
-    bool = is_convertible<_Rep2,
-                          typename common_type<typename _Duration::rep, _Rep2>::type>::value>
-struct __duration_divide_imp
-{
-};
-
-template <class _Rep1, class _Period, class _Rep2>
-struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
-{
-    typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
-};
+
    
+Change 24.5.1.3.5 [reverse.iter.opref]:
+
    
 
-template <class _Rep1, class _Period, class _Rep2>
-struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
-    : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
-{
-};
-
-template <class _Rep1, class _Period, class _Rep2>
-inline
-typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
-operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-{
-    typedef typename common_type<_Rep1, _Rep2>::type _Cr;
-    duration<_Cr, _Period> __r = __d;
-    __r /= static_cast<_Cr>(__s);
-    return __r;
-}
+
    pointer operator->() const;
+
    
+
    
+Returns:
+
    &(operator*());
+this->tmp = current;
+--this->tmp;
+return this->tmp;
 
    
+
    
+
    
+
    
+
 
-
    
-__duration_divide_result is basically a custom-built enable_if
-that will contain type only if Rep2 is not a duration
-and if Rep2 is implicitly convertible to
-common_type<typename Duration::rep, Rep2>::type. __is_duration
-is simply a private trait that answers false, but is specialized for
-duration to answer true.
-
    
 
+
    Proposed resolution:
    
 
    
-The constrained operator% works identically.
+Change 24.5.1.3.5 [reverse.iter.opref]:
 
    
+
+
    pointer operator->() const;
+
    
+
    
+Returns:
+
    &(operator*());
+deref_tmp = current;
+--deref_tmp;
+return deref_tmp::operator->();
+
    
+
    
 
    
 
 
-
    Proposed resolution:
    
-
    
-
    
+
+
 
 
 
 
 
 
    
-
    950. unique_ptr converting ctor shouldn't accept array form
    
-
    Section: 20.8.9.2.1 [unique.ptr.single.ctor] Status: Review
- Submitter: Howard Hinnant Opened: 2009-01-07  Last modified: 2009-08-01
    
-
    View other active issues in [unique.ptr.single.ctor].
    
-
    View all other issues in [unique.ptr.single.ctor].
    
-
    View all issues with Review status.
    
+
    1056. Must all Engines and Distributions be Streamable?
    
+
    Section: 26.5 [rand] Status: Tentatively NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-11-03
    
+
    View all other issues in [rand].
    
+
    View all issues with Tentatively NAD status.
    
 
    Discussion:
    
+
 
    
-unique_ptr's of array type should not convert to
-unique_ptr's which do not have an array type.
+Both the concepts RandomNumberEngine and RandomNumberDistribution have
+requirements to be InputStreamable and OutputStreamable.
+
    
+
    
+I have no problems leaving the WP in an inconsistent state on the best-faith
+assumption these concepts will be provided later, however disagree with the
+proposers that these constraints are not separable, orthogonal to the basic
+concepts of generating random number distributions.
+
    
+
    
+These constraints should be dropped, and applied to specific algorithms as
+needed.
+
    
+
    
+If a more refined concept (certainly deemed useful by the proposers) is
+proposed there is no objection, but the basic concept should not require
+persistence via streaming.
 
    
 
-
    struct Deleter
-{
-   void operator()(void*) {}
-};
+
    [
+Batavia (2009-05):
+]
    
 
-int main()
-{
-   unique_ptr<int[], Deleter> s;
-   unique_ptr<int, Deleter> s2(std::move(s));  // should not compile
-}
-
    
+
    
+Move to Open.
+
    
 
 
    [
-Post Summit:
+2009-05-31 Alisdair adds:
 ]
    
 
 
 
    
 
    
-Walter: Does the "diagnostic required" apply to both arms of the "and"?
-
    
-
    
-Tom Plum: suggest to break into several sentences
+Working on constraining the stream iterators, I have a few more observations
+to make on the concepts proposed while constraining the random number
+facility.
 
    
 
    
-Walter: suggest "comma" before the "and" in both places
+While I still believe the concerns are orthogonal, I don't believe the
+existing constraints go far enough either!  The goal we want to achieve is
+not that a RandomNumberEngine / RandomNumberDistribution supports the stream
+operators, but that it is Serializable.  I.e. there is a relationship
+between the insert and extract operations that guarantees to restore the
+state of the original object.  This implies a coupling of the concepts
+together in a broader concept (Serializable) with at least one axiom to
+assert the semantics.
 
    
 
    
-Recommend Review.
+One problem is that istream and ostream may be fundamentally different
+types, although we can hook a relation if we are prepared to drop down to
+the char type and char_traits template parameters.  Doing so ties us to a
+form of serialization that demands implementation via the std iostreams
+framework, which seems overly prescriptive.  I believe the goal is generally
+to support serialization without regard to how it is expressed - although
+this is getting even more inventive in terms of concepts we do not have
+today.
 
    
 
    
 
 
    [
-Batavia (2009-05):
+2009-11-03 Alisdair adds:
 ]
    
 
+
 
    
-The post-Summit comments have been applied to the proposed resolution.
-We now agree with the proposed resolution.
-Move to Tentatively Ready.
+
    
+I can't find the record in the wiki minutes, but it was agreed at both
+Frankfurt and Santa Cruz that this issue is NAD.
+
    
+
    
+The agreement in SC was that I would provide you with the rationale (see
+below) to include when moving to NAD.
+
    
 
    
 
 
    [
-2009-07 Frankfurt
+2009-11-03 Howard adds:
 ]
    
 
 
 
    
-Moved from Tentatively Ready to Open only because the wording needs to be
-improved for enable_if type constraining, possibly following Robert's
-formula.
+Moved to Tentatively NAD after 5 positive votes on c++std-lib.
 
    
 
-
    [
-2009-08-01 Howard updates wording and sets to Review.
-]
    
-
 
+
    Proposed resolution:
    
 
 
-
    Proposed resolution:
    
+
    Rationale:
    
 
    
-Change 20.8.9.2.1 [unique.ptr.single.ctor]:
+The issue suggests a more refined concept should be used if we want to
+require streaming, to separate concerns from the basic
+RandomNumberEngine behaviour.  In Frankfurt it was observed
+that RandomNumberEngine is that more refined concept,
+and the basic concept used in the framework is
+UniformRandomNumberGenerator, which it refines.
 
    
 
-
    
-
    template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);
-
    
-
    
 
    
--20- Requires: If D is not a reference type,
-construction of the deleter D from an rvalue of type E
-shall be well formed and shall not throw an exception. If D is
-a reference type, then E shall be the same type as D
-(diagnostic required). unique_ptr<U, E>::pointer shall be
-implicitly convertible to pointer. [Note: These requirements
-imply that T and U are complete types. — end note]
+We concur, and expect this to have no repurcussions re-writing this
+clause now concepts are removed.
 
    
 
-
    
-Remarks: If D is
-a reference type, then E shall be the same type as D, else this
-constructor shall not participate in overload resolution. unique_ptr<U, E>::pointer shall be
-implicitly convertible to pointer, else this
-constructor shall not participate in overload resolution. U shall not be
-an array type, else this
-constructor shall not participate in overload resolution. [Note: These requirements
-imply that T and U are complete types. — end note]
-
    
 
-
    
-
    
+
+
+
+
    
+
    1068. class random_device should be movable
    
+
    Section: 26.5.6 [rand.device] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-03-18  Last modified: 2009-10-26
    
+
    View all other issues in [rand.device].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
 
    
-Change 20.8.9.2.3 [unique.ptr.single.asgn]:
+class random_device should be movable.
 
    
 
+
    [
+Batavia (2009-05):
+]
    
+
 
    
-
    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);
-
    
+Move to Open, and recommend this issue be deferred until after the next
+Committee Draft is issued.
+
    
+
+
    [
+2009-10 post-Santa Cruz:
+]
    
+
+
 
    
+Leave open. Walter to provide drafting as part of his planned paper.
+
    
+
+
+
+
    Proposed resolution:
    
+
+
+
+
+
+
    
+
    1069. class seed_seq should support efficient move operations
    
+
    Section: 26.5.7.1 [rand.util.seedseq] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-03-18  Last modified: 2009-10-26
    
+
    View all other issues in [rand.util.seedseq].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
+
 
    
--6- Requires: Assignment of the deleter D from an rvalue
-D shall not throw an exception. unique_ptr<U,
-E>::pointer shall be implicitly convertible to pointer.
-[Note: These requirements imply that T and U
-are complete types. — end note]
+class seed_seq should support efficient move operations.
 
    
 
-
    
-Remarks: unique_ptr<U,
-E>::pointer shall be implicitly convertible to pointer, else this
-operator shall not participate in overload resolution.
-U shall not be an array type, else this
-operator shall not participate in overload resolution.
-[Note: These requirements imply that T and U
-are complete types. — end note]
-
    
+
    [
+Batavia (2009-05):
+]
    
 
+
    
+Move to Open, and recommend this issue be deferred until after the next
+Committee Draft is issued.
 
    
+
+
    [
+2009-10 post-Santa Cruz:
+]
    
+
+
+
    
+Leave open. Walter to provide drafting as part of his planned paper.
 
    
 
 
 
+
    Proposed resolution:
    
+
+
 
 
 
 
    
-
    951. Various threading bugs #1
    
-
    Section: 20.9.2.1 [time.traits.is_fp] Status: Open
- Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-08-01
    
-
    View all issues with Open status.
    
+
    1071. is_bind_expression should derive from integral_constant<bool>
    
+
    Section: 20.7.11.1.1 [func.bind.isbind] Status: Tentatively Ready
+ Submitter: Alisdair Meredith Opened: 2009-03-19  Last modified: 2009-10-26
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
 
    
-Related to 953.
+Class template is_bind_expression 20.7.11.1.1 [func.bind.isbind]:
 
    
 
+
    namespace std {
+  template<class T> struct is_bind_expression {
+    static const bool value = see below;
+  };
+}
+
    
 
    
-20.9.2.1 [time.traits.is_fp] says that the type Rep "is
-assumed to be ... a class emulating an integral type." What are the
-requirements for such a type?
+is_bind_expression should derive from std::integral_constant<bool> like
+other similar trait types.
 
    
+
 
    [
-2009-05-10 Howard adds:
+Daniel adds:
 ]
    
 
-
 
    
-IntegralLike.
+We need the same thing for the trait is_placeholder as well.
 
    
+
    [
+2009-03-22 Daniel provided wording.
+]
    
+
 
 
    [
 Batavia (2009-05):
@@ -19257,11 +16121,7 @@ Batavia (2009-05):
 
 
    
 
    
-As with issue 953,
-we recommend this issue be addressed in the context of providing concepts for the entire thread header.
-
    
-
    
-We look forward to proposed wording.
+We recommend this be deferred until after the next Committee Draft is issued.
 
    
 
    
 Move to Open.
@@ -19269,1468 +16129,1182 @@ Move to Open.
 
    
 
 
    [
-2009-08-01 Howard adds:
+2009-05-31 Peter adds:
 ]
    
 
 
 
    
 
    
-I have surveyed all clauses of 20.9.2.2 [time.traits.duration_values],
-20.9.2.3 [time.traits.specializations] and 20.9.3 [time.duration].
-I can not find any clause which involves the use of a duration::rep type
-where the requirements on the rep type are not clearly spelled out.
-These requirements were carefully crafted to allow any arithmetic type, or
-any user-defined type emulating an arithmetic type.
+I am opposed to the proposed resolution and to the premise of the issue
+in general. The traits's default definitions should NOT derive from
+integral_constant, because this is harmful, as it misleads people into
+thinking that is_bind_expression<E> always derives from
+integral_constant, whereas it may not.
 
    
-
 
    
-Indeed, treat_as_floating_point
-becomes completely superfluous if duration::rep can never be a class type.
+is_bind_expression and is_placeholder allow user
+specializations, and in fact, this is their primary purpose. Such user
+specializations may not derive from integral_constant, and the
+places where is_bind_expression and is_placeholder are
+used intentionally do not require such derivation.
 
    
-
 
    
-There will be some Rep types which will not meet the requirements of
-every duration operation.  This is no different than the fact
-that vector<T> can easily be used for types T which are
-not DefaultConstructible, even though some members of vector<T>
-require T to be DefaultConstructible.  This is why the requirements
-on Rep are specified for each operation individually.
+The long-term approach here is to switch to
+BindExpression<E> and Placeholder<P>
+explicit concepts, of course, but until that happens, I say leave them
+alone.
 
    
+
    
 
-
    
-In 20.9.2.1 [time.traits.is_fp] p1:
-
    
+
    [
+2009-10 post-Santa Cruz:
+]
    
 
-
    template <class Rep> struct treat_as_floating_point 
-  : is_floating_point<Rep> { };
-
    
 
 
    
-The duration template uses the treat_as_floating_point trait to help
-determine if a duration object can be converted to another duration
-with a different tick period. If treat_as_floating_point<Rep>::value is
-true, then Rep is a floating-point type and implicit conversions are
-allowed among durations. Otherwise, the implicit convertibility depends
-on the tick periods of the durations. If Rep is a class type which
-emulates a floating-point type, the author of Rep can specialize
-treat_as_floating_point so that duration will treat this Rep as if it
-were a floating-point type. Otherwise Rep is assumed to be an integral
-type or a class emulating an integral type.
-
    
+Move to Tentatively Ready.  We are comfortable with requiring user specializations
+to derive from integral_constant.
 
    
 
-
    
-The phrases "a class type which emulates a floating-point type" and
-"a class emulating an integral type" are clarifying phrases which refer to
-the summation of all the requirements on the Rep type specified in
-detail elsewhere (and should not be repeated here).
-
    
 
-
    
-This specification has been implemented, now multiple times, and the experience
-has been favorable.  The current specification clearly specifies the requirements
-at each point of use (though I'd be happy to fix any place I may have missed,
-but none has been pointed out).
-
    
 
+
    Proposed resolution:
    
+
      
+
    1. 
 
      
-I am amenable to improved wording of this paragraph (and any others), but to not have any
-suggestions for improved wording at this time.  I am strongly opposed to
-changes which would significantly alter the semantics of the
-specification under 20.9 [time] without firmly grounded and
-documented rationale, example implementation, testing, and user
-experience which relates a positive experience.
+In 20.7.11.1.1 [func.bind.isbind] change as indicated:
 
      
-
+
      namespace std {
+ template<class T> struct is_bind_expression : integral_constant<bool, see below> { };{
+   static const bool value = see below;
+ };
+}
+
      
+
      2. 
+
    2. 
 
      
-I recommend NAD unless someone wants to produce some clarifying wording.
+In 20.7.11.1.1 [func.bind.isbind]/2 change as indicated:
 
      
+
      static const bool value;
+
      
+
      
+-2- true if T is a type returned from bind, false otherwise.
+  If T is a type returned from bind, is_bind_expression<T> shall
+be publicly derived from
+        integral_constant<bool, true>, otherwise it shall be
+publicly derived from
+          integral_constant<bool, false>.
 
      
-
-
-
      Proposed resolution:
      
+
      
+
      3. 
+
    3. 
+
      
+In 20.7.11.1.2 [func.bind.isplace] change as indicated:
+
      
+
      namespace std {
+ template<class T> struct is_placeholder : integral_constant<int, see below> { };{
+   static const int value = see below;
+ };
+}
+
      
+
      4. 
+
    4. 
 
      
+In 20.7.11.1.2 [func.bind.isplace]/2 change as indicated:
 
      
+
      static const int value;
+
      
+
      
+-2- value is J if T is the type of std::placeholders::_J, 0 otherwise.
+  If T is the type of std::placeholders::_J, is_placeholder<T>
+shall be publicly
+          derived from integral_constant<int, J> otherwise it shall
+be publicly derived
+          from integral_constant<int, 0>.
+
      
+
      
+
      5. 
+
    
 
 
 
 
 
 
    
-
    953. Various threading bugs #3
    
-
    Section: 20.9.1 [time.clock.req] Status: Open
- Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-08-01
    
-
    View other active issues in [time.clock.req].
    
-
    View all other issues in [time.clock.req].
    
+
    1076. unary/binary_negate need constraining and move support
    
+
    Section: 20.7.10 [negators] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-03-20  Last modified: 2009-10-26
    
 
    View all issues with Open status.
    
 
    Discussion:
    
-
 
    
-Related to 951.
+The class templates unary/binary_negate need constraining and move support.
 
    
-
 
    
-20.9.1 [time.clock.req] says that a clock's rep member is "an
-arithmetic type or a class emulating an arithmetic type." What are the
-requirements for such a type?
+Ideally these classes would be deprecated, allowing unary/binary_function to
+also be deprecated.  However, until a generic negate adaptor is introduced
+that can negate any Callable type, they must be supported so should be
+constrained.  Likewise, they should be movable, and support adopting a
+move-only predicate type.
+
    
+
    
+In order to preserve ABI compatibility, new rvalue overloads are supplied in
+preference to changing the existing pass-by-const-ref to pass-by-value.
+
    
+
    
+Do not consider the issue of forwarding mutable lvalues at this point,
+although remain open to another issue on the topic.
 
    
 
 
    [
-2009-05-10 Howard adds:
+2009-05-01 Daniel adds:
 ]
    
 
-
 
    
-This wording was aimed directly at the ArithmeticLike concept.
-
    
-
-
    [
-Batavia (2009-05):
-]
    
+
    
+IMO the currently proposed resolution needs some updates
+because it is ill-formed at several places:
+
    
 
-
    
+
      
+
    1. 
 
      
-We recommend this issue be addressed in the context of providing concepts
-for the entire thread header.
+In concept AdaptableUnaryFunction change
 
      
+
      typename X::result_type;
+typename X::argument_type;
+
      
 
      
-May resolve for now by specifying arithmetic types,
-and in future change to ArithmeticLike.
-However, Alisdair believes this is not feasible.
+to
 
      
+
      Returnable result_type = typename X::result_type;
+typename argument_type = typename X::argument_type;
+
      
 
      
-Bill disagrees.
+[The replacement "Returnable result_type" instead of "typename
+result_type" is non-editorial, but maybe you prefer that as well]
 
      
+
      2. 
+
    2. 
 
      
-We look forward to proposed wording.  Move to Open.
+In concept AdaptableBinaryFunction change
 
      
-
    
-
-
    [
-2009-08-01 Howard adds:
-]
    
-
-
-
    
-See commented dated 2009-08-01 in 951.
-
    
-
-
-
    Proposed resolution:
    
+
    typename X::result_type;
+typename X::first_argument_type;
+typename X::second_argument_type;
+
    
+
    
+to
+
    
+
    Returnable result_type = typename X::result_type;
+typename first_argument_type = typename X::first_argument_type;
+typename second_argument_type = typename X::second_argument_type;
+
    
 
    
+[The replacement "Returnable result_type" instead of "typename
+result_type" is non-editorial, but maybe you prefer that as well.]
 
    
+
 
-
-
-
-
-
    
-
    954. Various threading bugs #4
    
-
    Section: 20.9.1 [time.clock.req] Status: Review
- Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-08-01
    
-
    View other active issues in [time.clock.req].
    
-
    View all other issues in [time.clock.req].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
+
  • 
 
    
-Table 55 -- Clock Requirements (in 20.9.1 [time.clock.req])
+In class unary/binary_function
 
    
-
 
      
 
    1. 
-the requirements for C1::time_point require C1 and C2
-to "refer to the same epoch", but "epoch" is not defined.
-
      2. 
-
    2. 
-"Different clocks may share a time_point definition if it is
-valid to compare their time_points by comparing their
-respective durations." What does "valid" mean here? And, since
-C1::rep is "**THE** representation type of the native
-duration and time_point" (emphasis added), there
-doesn't seem to be much room for some other representation.
-
      3. 
-
    3. 
-C1::is_monotonic has type "const bool". The
-"const" should be removed.
+I suggest to change "ReturnType" to "Returnable" in both cases.
 
      4. 
 
    4. 
-C1::period has type ratio. ratio isn't a type, 
-it's a template. What is the required type?
+I think you want to replace the remaining occurrences of "Predicate" by "P"
+(in both classes in copy/move from a predicate)
 
      5. 
 
    
-
-
    [
-2009-05-10 Howard adds:
-]
    
-
-
-
      
-
    1. 
-
      
-"epoch" is purposefully not defined beyond the common English
-definition.  The C standard
-also chose not to define epoch, though POSIX did.  I believe it is a strength
-of the C standard that epoch is not defined.  When it is known that two time_points
-refer to the same epoch, then a definition of the epoch is not needed to compare
-the two time_points, or subtract them.
-
      
-
      
-A time_point and a Clock implicitly refer to an (unspecified) epoch.
-The time_point represents an offset (duration) from an epoch.
-
      
 
      2. 
 
    2. 
 
      
-The sentence:
-
      
-
      
-Different clocks 
-may share a time_point
-definition if it is valid to 
-compare their time_points by 
-comparing their respective 
-durations.
-
      
-
-
      
-is redundant and could be removed.  I believe the sentence which follows the above:
+I think you need to change the proposed signatures of not1 and not2, because
+they would still remain unconstrained: To make them constrained at least a
+single requirement needs to be added to enable requirement implication. This
+could be done via a dummy ("requires True<true>") or just explicit as follows:
 
      
-
+
        
+
      1. 
+
        template <AdaptableUnaryFunction P>
+requires Predicate< P, P::argument_type>
+unary_negate<P> not1(const P&& pred);
+template <AdaptableUnaryFunction P>
+requires Predicate< P, P::argument_type >
+unary_negate<P> not1(P&& pred);
+
        
 
        
-C1 and C2 shall refer to the same epoch.
+-3- Returns: unary_negate<P>(pred).
+
        
 
        
-
 
        
-is sufficient.  If two clocks share the same epoch, then by definition, comparing
-their time_points is valid.
+[Don't we want a move call for the second overload as in
 
        
-
        2. 
-
      2. 
-is_monotonic is meant to never change (be const).  It is also
-desired that this value be usable in compile-time computation and branching.
-
        3. 
-
      3. 
+
        unary_negate<P>(std::move(pred))
+
        
 
        
-This should probably instead be worded:
+in the Returns clause ?]
 
        
-
        
-An instantiation of ratio.
-
        
 
        4. 
-
      
-
-
      [
-Batavia (2009-05):
-]
      
-
-
      
+
    3. 
+
      template <AdaptableBinaryFunction P>
+requires Predicate< P, P::first_argument_type, P::second_argument_type >
+binary_negate<P> not2(const P& pred);
+template <AdaptableBinaryFunction P>
+requires Predicate< P, P::first_argument_type, P::second_argument_type >
+binary_negate<P> not2(P&& pred);
+
      
 
      
-Re (a): It is not clear to us whether "epoch" is a term of art.
+-5- Returns: binary_negate<P>(pred).
 
      
 
      
-Re (b), (c), and (d):  We agree with Howard's comments,
-and would consider adding to (c) a static constexpr requirement.
+[Don't we want a move call for the second overload as in
 
      
+
      binary_negate<P>(std::move(pred))
+
      
 
      
-Move to Open pending proposed wording.
+in the Returns clause ?]
 
      
+
      4. 
+
    
+
    • 
+
 
    
 
 
    [
-2009-05-25 Daniel adds:
-]
    
-
-
-
    
-In regards to (d) I suggest to say "a specialization of ratio" instead of
-"An instantiation of ratio". This seems to be the better matching standard
-core language term for this kind of entity.
-
    
-
-
    [
-2009-05-25 Ganesh adds:
+Batavia (2009-05):
 ]
    
 
-
 
    
 
    
-Regarding (a), I found this paper on the ISO website using the term "epoch" consistently with the current wording:
+There is concern that complicating the solution
+to preserve the ABI seems unnecessary,
+since we're not in general preserving the ABI.
 
    
-
 
    
-http://standards.iso.org/ittf/PubliclyAvailableStandards/C030811e_FILES/MAIN_C030811e/text/ISOIEC_18026E_TEMPORAL_CS.HTM
+We would prefer a separate paper consolidating all Clause 20
+issues that are for the purpose of providing constrained versions
+of the existing facilities.
 
    
 
    
-which is part of ISO/IEC 18026 "Information technology -- Spatial Reference Model (SRM)".
+Move to Open.
 
    
 
    
 
 
    [
-2009-08-01 Howard: Moved to Reivew as the wording requested in Batavia has been provided.
+2009-10 post-Santa Cruz:
 ]
    
 
 
-
-
-
    Proposed resolution:
    
-
      
-
    1. 
-
      
-Change 20.9.1 [time.clock.req] p1:
-
      
 
      
--1- A clock is a bundle consisting of a native duration, a native time_point, and a function now() to get the 
-current time_point.  The origin of the clock's time_point is referred to as the clock's epoch as defined in 
-section 6.3 of ISO/IEC 18026.
-A clock shall meet the requirements in Table 45.
+Leave open pending the potential move constructor paper. Note that
+we consider the "constraining" part NAD Concepts.
 
      
-
      2. 
-
    2. 
-
      
-Remove the sentence from the time_point row of the table "Clock Requirements":
-
      
-
-
-
-
-
-
-
-
      Clock requirements
      
-C1::time_point
-
-chrono::time_point<C1> or chrono::time_point<C2, C1::duration>
-
-The native time_point type of the clock.
-Different clocks may share a time_point definition if it is valid to compare their time_points by comparing their respective durations.
-C1 and C2 shall refer to the same epoch.
-
      
-
      3. 
-
    
-
      
-
    1. 
-
      
-Change the row starting with C1::period of the table "Clock Requirements":
-
      
-
-
-
-
-
-
-
-
      Clock requirements
      
-C1::period
-
-a specialization of ratio
-
-The tick period of the clock in seconds.
-
      
-
-
      2. 
-
    
 
 
 
-
-
-
    
-
    955. Various threading bugs #5
    
-
    Section: 20.9.1 [time.clock.req] Status: Open
- Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-06-07
    
-
    View other active issues in [time.clock.req].
    
-
    View all other issues in [time.clock.req].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    Proposed resolution:
    
 
    
-20.9.1 [time.clock.req] requires that a clock type have a member
-typedef named time_point that names an instantiation of the
-template time_point, and a member named duration that
-names an instantiation of the template duration. This mixing of
-levels is confusing. The typedef names should be different from the
-template names.
+Add new concepts where appropriate::
 
    
 
-
    [
-Post Summit, Anthony provided proposed wording.
-]
    
-
-
-
    [
-2009-05-04 Howard adds:
-]
    
+
    auto concept AdaptableUnaryFunction< typename X > {
+  typename X::result_type;
+  typename X::argument_type;
+}
 
+auto concept AdaptableBinaryFunction< typename X > {
+  typename X::result_type;
+  typename X::first_argument_type;
+  typename X::second_argument_type;
+}
+
    
 
-
    
 
    
-The reason that the typedef names were given the same name as the class templates
-was so that clients would not have to stop and think about whether they were
-using the clock's native time_point / duration or the class
-template directly.  In this case, one person's confusion is another person's
-encapsulation.  The detail that sometimes one is referring to the clock's
-native types, and sometimes one is referring to an independent type is
-purposefully "hidden" because it is supposed to be an unimportant
-detail.  It can be confusing to have to remember when to type duration
-and when to type duration_type, and there is no need to require the
-client to remember something like that.
+Revise as follows:
 
    
 
 
    
-For example, here is code that I once wrote in testing out the usability of
-this facility:
+Base 20.7.3 [base] (Only change is constrained Result)
 
    
 
-
    template <class Clock, class Duration>
-void do_until(const std::chrono::time_point<Clock, Duration>& t)
-{
-    typename Clock::time_point now = Clock::now();
-    if (t > now)
-    {
-        typedef typename std::common_type
-        <
-            Duration,
-            typename std::chrono::system_clock::duration
-        >::type CD;
-        typedef std::chrono::duration<double, std::nano> ID;
-
-        CD d = t - now;
-        ID us = duration_cast<ID>(d);
-        if (us < d)
-            ++us;
-        ...
-    }
-}
-
    
-
+
    
 
    
-I see no rationale to require the client to append _type to some
-of those declarations.  It seems overly burdensome on the author of do_until:
+-1-  The following classes are provided to simplify the typedefs of the
+argument and result types:
 
    
+
    namespace std {
+  template <class Arg, class ReturnType Result>
+  struct unary_function {
+     typedef Arg    argument_type;
+     typedef Result result_type;
+  };
 
-
    template <class Clock, class Duration>
-void do_until(const std::chrono::time_point<Clock, Duration>& t)
-{
-    typename Clock::time_point_type now = Clock::now();
-    if (t > now)
-    {
-        typedef typename std::common_type
-        <
-            Duration,
-            typename std::chrono::system_clock::duration_type
-        >::type CD;
-        typedef std::chrono::duration<double, std::nano> ID;
-
-        CD d = t - now;
-        ID us = duration_cast<ID>(d);
-        if (us < d)
-            ++us;
-        ...
-    }
+  template <class Arg1, class Arg2, class ReturnType Result>
+  struct binary_function {
+     typedef Arg1   first_argument_type;
+     typedef Arg2   second_argument_type;
+     typedef Result result_type;
+  };
 }
 
    
 
 
    
-Additionally I'm fairly certain that this suggestion hasn't been implemented.
-If it had, it would have been discovered that it is incomplete.  time_point
-also has a nested type (purposefully) named duration.
+Negators 20.7.10 [negators]:
 
    
+
 
    
-That is, the current proposed wording would put the WP into an inconsistent state.
-
    
 
    
-In contrast,
-the current WP has been implemented and I've received very favorable feedback
-from people using this interface in real-world code.
+-1- Negators not1 and not2 take a unary and a binary predicate,
+respectively, and return their complements (5.3.1).
 
    
 
-
    
+
    template <class AdaptableUnaryFunction Predicate>
+  requires Predicate< P, P::argument_type >
+  class unary_negate
+    : public unary_function<typename Predicate::argument_type,bool> {
+  public:
+    unary_negate(const unary_negate & ) = default;
+    unary_negate(unary_negate && );
 
-
    [
-Batavia (2009-05):
-]
    
+    requires CopyConstructible< P >
+       explicit unary_negate(const Predicate& pred); 
+    requires MoveConstructible< P >
+       explicit unary_negate(Predicate && pred);
 
+    bool operator()(const typename Predicate::argument_type& x) const;
+  };
+
    
 
    
-
    
-Bill agrees that distinct names should be used for distinct kinds of entities.
-
    
-
    
-Walter would prefer not to suffix type names,
-especially for such well-understood terms as "duration".
-
    
-
    
-Howard reminds us that the proposed resolution is incomplete, per his comment
-in the issue.
-
    
-
    
-Move to Open.
-
    
+-2 operator() returns !pred(x).
 
    
 
-
    [
-2009-06-07 Howard adds:
-]
    
-
-
+
    template <class Predicate>
+  unary_negate<Predicate> not1(const Predicate&amp; pred);
+template <class Predicate>
+  unary_negate<Predicate> not1(Predicate&& pred);
+
    
 
    
-
    
-Not meaning to be argumentative, but we have a decade of positive experience
-with the precedent of using the same name for the nested type as an external
-class representing an identical concept.
-
    
+-3-  Returns: unary_negate<Predicate>(pred).
+
    
 
-
    template<class Category, class T, class Distance = ptrdiff_t,
-         class Pointer = T*, class Reference = T&>
-struct iterator
-{
-    ...
-};
+
    template <class AdaptableBinaryFunction Predicate >
+  requires Predicate< P, P::first_argument_type, P::second_argument_type >
+  class binary_negate
+    : public binary_function<typename Predicate::first_argument_type,
+                              typename Predicate::second_argument_type, bool> {
+  public:
+    biary_negate(const binary_negate & ) = default;
+    binary_negate(binary_negate && );
 
-template <BidirectionalIterator Iter>
-class reverse_iterator
-{
-    ...
-};
+    requires CopyConstructible< P >
+       explicit binary_negate(const Predicate& pred);
+    requires MoveConstructible< P >
+       explicit binary_negate(const Predicate& pred);
 
-template <ValueType T, Allocator Alloc = allocator<T> >
-    requires NothrowDestructible<T>
-class list
-{
-public:
-    typedef implementation-defined     iterator;
-    ...
-    typedef reverse_iterator<iterator> reverse_iterator;
-    ...
-};
-
    
+    bool operator()(const typename Predicate::first_argument_type& x,
+                    const typename Predicate::second_argument_type& y) const;
+  };
+
    
+
    
+-4- operator() returns !pred(x,y).
+
    
 
-
    
-I am aware of zero complaints regarding the use of iterator
-and reverse_iterator as nested types of the containers despite these
-names also having related meaning at namespace std scope.
-
    
+
    template <class Predicate>
+  binary_negate<Predicate> not2(const Predicate& pred);
+template <class Predicate>
+  binary_negate<Predicate> not2(Predicate&& pred);
+
    
 
-
    
-Would we really be doing programmers a favor by renaming these nested types?
-
    
+
    
+-5- Returns: binary_negate<Predicate>(pred).
+
    
+
    
 
-
    template <ValueType T, Allocator Alloc = allocator<T> >
-    requires NothrowDestructible<T>
-class list
-{
-public:
-    typedef implementation-defined     iterator_type;
-    ...
-    typedef reverse_iterator<iterator> reverse_iterator_type;
-    ...
-};
-
    
 
-
    
-I submit that such design contributes to needless verbosity which ends up
-reducing readability.
-
    
-
    
 
 
 
-
    Proposed resolution:
    
-
    
-Change 20.9 [time]:
-
    
 
-
    ...
-template <class Clock, class Duration = typename Clock::duration_type> class time_point;
-...
-
    
+
    
+
    1079. UK-265: RandomAccessIterator's operator- has nonsensical effects clause
    
+
    Section: 24.2.5 [random.access.iterators] Status: Ready
+ Submitter: Doug Gregor Opened: 2009-03-20  Last modified: 2009-10-23
    
+
    View all other issues in [random.access.iterators].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
+
    Addresses UK 265
    
 
+
    UK-265:
    
 
    
-Change 20.9.1 [time.clock.req]:
+This effects clause is nonesense. It looks more like an axiom stating
+equivalence, and certainly an effects clause cannot change the state of
+two arguments passed by const reference
 
    
 
-
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    Table 45 -- Clock requirements
    ExpressionReturn typeOperational semantics
    .........
    C1::duration_typechrono::duration<C1::rep, C1::period>The native duration type of the clock.
    C1::time_point_typechrono::time_point<C1> or chrono::time_point<C2, C1::duration_type<The native time_point type of the clock.   Different clocks may  share a time_point_type
-definition if it is valid to 
-compare their time_point_types by 
-comparing their respective 
-duration_types. C1 and C2 shall 
-refer to the same epoch.
    .........
    C1::now()C1::time_point_typeReturns a time_point_type object 
-representing the current point 
-in time.
-
    
-
    
+
    [
+2009-09-18 Alisdair adds:
+]
    
 
-
    
-Change 20.9.5.1 [time.clock.system]:
-
    
 
 
    
 
    
--1- Objects of class system_clock represent wall clock time from the system-wide realtime clock.
+For random access iterators, the definitions of (b-a) and
+(a<b) are circular:
 
    
 
-
    class system_clock { 
-public: 
-  typedef see below rep; 
-  typedef ratio<unspecified, unspecified> period; 
-  typedef chrono::duration<rep, period> duration_type; 
-  typedef chrono::time_point<system_clock> time_point_type; 
-  static const bool is_monotonic = unspecified ; 
-
-  static time_point_type now(); 
-
-  // Map to C API 
-  static time_t to_time_t (const time_point_type& t); 
-  static time_point_type from_time_t(time_t t); 
-};
-
    
-
 
    
--2- system_clock::duration_type::min() < system_clock::duration_type::zero() shall be true.
+From table Table 104 -- Random access iterator requirements:
 
    
 
-
    time_t to_time_t(const time_point_type& t);
-
    
+
    b - a :==>  (a < b) ? distance(a,b) : -distance(b,a)
 
-
    
--3- Returns: A time_t object that represents the same
-point in time as t when both values are truncated to the
-coarser of the precisions of time_t and time_point_type.
+a < b :==>  b - a > 0
+
    
 
    
 
-
    time_point_type from_time_t(time_t t);
-
    
+
    [
+2009-10 Santa Cruz:
+]
    
+
 
 
    
--4- Returns: A time_point_type object that represents the same point
-in time as t when both values are truncated to the coarser of the
-precisions of time_t and time_point_type.
-
    
+Moved to Ready.
    -

    -Change 20.9.5.2 [time.clock.monotonic]: -

    - -
    class monotonic_clock { 
-public: 
-  typedef unspecified                                rep; 
-  typedef ratio<unspecified , unspecified>           period; 
-  typedef chrono::duration<rep, period>              duration_type; 
-  typedef chrono::time_point<unspecified , duration_type> time_point_type; 
-  static const bool is_monotonic =                   true; 
 
-  static time_point_type now();
-};
-
    - -

    -Change 20.9.5.3 [time.clock.hires]: -

    -
    class high_resolution_clock { 
-public: 
-  typedef unspecified                                rep; 
-  typedef ratio<unspecified , unspecified>           period; 
-  typedef chrono::duration<rep, period>              duration_type; 
-  typedef chrono::time_point<unspecified , duration_type> time_point_type; 
-  static const bool is_monotonic =                   true; 
+
    Proposed resolution:
    
 
-  static time_point_type now();
-};
-
    +

    Modify 24.2.5 [random.access.iterators]p7-9 as follows:

    +
    difference_type operator-(const X& a, const X& b);
+
    +
      +
    1. Precondition: there exists a value n of + difference_type such that a == b + n.
      2. +
    2. Effects: b == a + (b - a)
      3. +
    3. Returns: (a < b) ? distance(a,b) : + -distance(b,a)n
      4. +
    +
    -

    956. Various threading bugs #6

    -

    Section: 20.9.1 [time.clock.req] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-05-23

    -

    View other active issues in [time.clock.req].

    -

    View all other issues in [time.clock.req].

    +

    1089. Response to JP 76

    +

    Section: 30 [thread] Status: Open + Submitter: Howard Hinnant Opened: 2009-03-22 Last modified: 2009-10-23

    +

    View all other issues in [thread].

    View all issues with Open status.

    Discussion:

    +

    Addresses JP 76

    +

    -20.9.1 [time.clock.req] uses the word "native" in several places, -but doesn't define it. What is a "native duration"? +A description for "Throws: Nothing." are not unified.

    -

    [ -2009-05-10 Howard adds: -]

    - - -
    -The standard uses "native" in several places without defining it (e.g. -2.14.3 [lex.ccon]). It is meant to mean "that which is defined -by the facility", or something along those lines. In this case it refers -to the nested time_point and duration types of the clock. -Better wording is welcome. -
    - -

    [ -Batavia (2009-05): -]

    - -
    -Move to Open pending proposed wording from Pete. -
    - - -

    Proposed resolution:

    +At the part without throw, "Throws: Nothing." should be described.

    - - - - -
    -

    957. Various threading bugs #7

    -

    Section: 20.9.5.1 [time.clock.system] Status: Review - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-05-23

    -

    View all other issues in [time.clock.system].

    -

    View all issues with Review status.

    -

    Discussion:

    -20.9.5.1 [time.clock.system]: to_time_t is overspecified. It -requires truncation, but should allow rounding. For example, suppose a -system has a clock that gives times in milliseconds, but time() rounds -those times to the nearest second. Then system_clock can't use any -resolution finer than one second, because if it did, truncating times -between half a second and a full second would produce the wrong time_t -value. +Add "Throws: Nothing." to the following.

    +
      +
    • +30.3.1.6 [thread.thread.static] p1 +
      • +
    • +30.4.3.1 [thread.lock.guard] p4 +
      • +
    • +30.4.3.2.1 [thread.lock.unique.cons] p6 +
      • +
    • +30.5.1 [thread.condition.condvar] p7 and p8 +
      • +
    • +30.5.2 [thread.condition.condvarany] p6, p7, p19, p21 and p25 +
      • +
    +

    [ -Post Summit Anthony Williams provided proposed wording. +Summit: ]

    +
    +Pass on to editor. +

    [ -Batavia (2009-05): +Post Summit: Editor declares this non-editorial. ]

    -
    -Move to Review pending input from Howard. and other stakeholders. -

    [ -2009-05-23 Howard adds: +2009-08-01 Howard provided wording: ]

    -I am in favor of the wording provided by Anthony. -
    - -

    Proposed resolution:

    -In 20.9.5.1 [time.clock.system] replace paragraphs 3 and 4 with: +The definition of "Throws: Nothing." that I added is probably going to +be controversial, but I beg you to consider it seriously.

    -
    time_t to_time_t(const time_point& t);
-
    -
    --3- Returns: A time_t object that represents the same -point in time as t when both values are truncated -restricted to the coarser of the precisions of -time_t and time_point. It is implementation -defined whether values are rounded or truncated to the required -precision. -
    - -
    time_point from_time_t(time_t t);
-
    -
    --4- Returns: A time_point object that represents the -same point in time as t when both values are truncated -restricted to the -coarser of the precisions of time_t and time_point. -It is implementation defined whether values are -rounded or truncated to the required precision. -
    -
    - - - - +

    +In C++ there are three "flow control" options for a function: +

    -
    -

    958. Various threading bugs #8

    -

    Section: 30.5.1 [thread.condition.condvar] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-08-01

    -

    View other active issues in [thread.condition.condvar].

    -

    View all other issues in [thread.condition.condvar].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    -30.5.1 [thread.condition.condvar]: the specification for wait_for -with no predicate has an effects clause that says it calls wait_until, -and a returns clause that sets out in words how to determine the return -value. Is this description of the return value subtly different from the -description of the value returned by wait_until? Or should the effects -clause and the returns clause be merged? -

    +
      +
    1. +It can return, either with a value, or with void. +
      2. +
    2. +It can call a function which never returns, such as std::exit or +std::terminate. +
      3. +
    3. +It can throw an exception. +
      4. +
    -

    [ -Summit: -]

    +The above list can be abbreviated with: +
      +
    1. Returns.
      2. +
    2. Ends program.
      3. +
    3. Throws exception.
      4. +
    -
    -Move to open. Associate with LWG 859 and any other monotonic-clock -related issues. -
    +

    +In general a function can have the behavior of any of these 3, or any combination +of any of these three, depending upon run time data. +

    -

    [ -2009-08-01 Howard adds: -]

    +
      +
    1. R
      2. +
    2. E
      3. +
    3. T
      4. +
    4. RE
      5. +
    5. RT
      6. +
    6. ET
      7. +
    7. RET
      8. +
    +

    +A function with no throw spec, and no documentation, is in general a RET +function. It may return, it may end the program, or it may throw. When we +specify a function with an empty throw spec: +

    -
    -I believe that 859 (currently Ready) addresses this issue, and -that this issue should be marked NAD, solved by 859 (assuming -it moves to WP). -
    +
    void f() throw();
+
    +

    +We are saying that f() is an RE function: It may return or end +the program, but it will not throw. +

    +

    +I posit that there are very few places in the library half of the standard +where we intend for functions to be able to end the program (call terminate). +And none of those places where we do say terminate could be called, +do we currently say "Throws: Nothing.". +

    -

    Proposed resolution:

    +I believe that if we define "Throws: Nothing." to mean R, +we will both clarify many, many places in the standard, and give us a +good rationale for choosing between "Throws: Nothing." (R) +and throw() (RE) in the future. Indeed, this may give us motivation +to change several throw()s to "Throws: Nothing.".

    +
    +

    +I did not add the following changes as JP 76 requested as I believe we want to +allow these functions to throw: +

    +
    +

    +Add a paragraph under 30.4.3.1 [thread.lock.guard] p4: +

    +
    explicit lock_guard(mutex_type& m);
+
    +

    +Throws: Nothing. +

    +
    -
    -

    959. Various threading bugs #9

    -

    Section: 30.5.1 [thread.condition.condvar] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-08-01

    -

    View other active issues in [thread.condition.condvar].

    -

    View all other issues in [thread.condition.condvar].

    -

    View all issues with Open status.

    -

    Discussion:

    -30.5.1 [thread.condition.condvar]: condition_variable::wait_for -is required to compute the absolute time by adding the duration value to -chrono::monotonic_clock::now(), but monotonic_clock is not required to -exist. +Add a paragraph under 30.4.3.2.1 [thread.lock.unique.cons] p6:

    -

    [ -Summit: -]

    - +
    explicit unique_lock(mutex_type& m);
+
    -
    -Move to open. Associate with LWG 859 and any other monotonic-clock -related issues. +

    +Throws: Nothing. +

    -

    [ -2009-08-01 Howard adds: -]

    +

    +Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25: +

    +
    template <class Lock, class Rep, class Period> 
+  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
+
    -
    -I believe that 859 (currently Ready) addresses this issue, and -that this issue should be marked NAD, solved by 859 (assuming -it moves to WP). +

    +Throws: Nothing. +

    +
    template <class Lock, class Duration, class Predicate> 
+  bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& rel_time, Predicate pred);
+
    +

    +Throws: Nothing. +

    +
    -

    Proposed resolution:

    -

    -

    - - +
    template <class Lock, class Rep, class Period, class Predicate> 
+  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
+
    +

    +Throws: Nothing. +

    +
    +
    -
    -

    960. Various threading bugs #10

    -

    Section: 30.4.1 [thread.mutex.requirements] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-27

    -

    View other active issues in [thread.mutex.requirements].

    -

    View all other issues in [thread.mutex.requirements].

    -

    View all issues with Open status.

    -

    Discussion:

    -

    -30.4.1 [thread.mutex.requirements]: paragraph 4 is entitled -"Error conditions", but according to 17.5.1.4 [structure.specifications], "Error -conditions:" specifies "the error conditions for error codes reported by -the function." It's not clear what this should mean when there is no -function in sight. -

    +

    [ -Summit: +2009-10 Santa Cruz: ]

    -Move to open. +Defer pending further developments with exception restriction annotations.
    -

    [ -Beman provided proposed wording. -]

    -

    Proposed resolution:

    -Change 30.4.1 [thread.mutex.requirements] Mutex requirements, -paragraph 4 as indicated: +Add a paragraph after 17.5.1.4 [structure.specifications] p4:

    --4- Error conditions: -The error conditions for error codes, if any, reported by member -functions of type Mutex shall be: +-3- Descriptions of function semantics contain the following elements +(as appropriate):158

      +
    • ...
    • -not_enough_memory -- if there is not enough memory to construct -the mutex object. -
      • -
    • -resource_unavailable_try_again -- if any native handle type -manipulated is not available. -
      • -
    • -operation_not_permitted -- if the thread does not have the -necessary permission to change the state of the mutex object. -
      • -
    • -device_or_resource_busy -- if any native handle type -manipulated is already locked. -
      • -
    • -invalid_argument -- if any native handle type manipulated as -part of mutex construction is incorrect. +Throws: any exceptions thrown by the function, and the conditions +that would cause the exception
      • +
    • ...
    -
    +

    +-4- For non-reserved replacement and handler functions, ... +

    +

    +A "Throws: Nothing." element indicates that the function shall +return ordinarily, and not exit via an exception. This element also +indicates that the function shall return. [Note: This +differs from an empty throw specification which may cause a function to +call unexpected and subsequently terminate. — +end note] +

    +
    +

    +Add a paragraph under 30.3.1.6 [thread.thread.static] p1: +

    +
    unsigned hardware_concurrency();
+
    -
    -

    961. Various threading bugs #11

    -

    Section: 30.4.1 [thread.mutex.requirements] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22

    -

    View other active issues in [thread.mutex.requirements].

    -

    View all other issues in [thread.mutex.requirements].

    -

    View all issues with Open status.

    -

    Discussion:

    -30.4.1 [thread.mutex.requirements] describes required member -functions of mutex types, and requires that they throw exceptions under -certain circumstances. This is overspecified. User-defined types can -abort on such errors without affecting the operation of templates -supplied by standard-library. +-1- Returns: ...

    -

    [ -Summit: -]

    - -
    -Move to open. Related to conceptualization and should probably be -tackled as part of that. +

    +Throws: Nothing. +

    +

    +Add a paragraph under 30.5.1 [thread.condition.condvar] p7 and p8: +

    -

    Proposed resolution:

    +

    +[Informational, not to be incluced in the WP: The POSIX spec allows only:

    +
    +
    [EINVAL]
    +
    The value cond does not refer to an initialized condition variable. — end informational]
    +
    +
    void notify_one();
+
    +

    +-7- Effects: ... +

    +

    +Throws: Nothing. +

    +
    +
    void notify_all();
+
    -
    -

    962. Various threading bugs #12

    -

    Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: Review - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-07-21

    -

    View other active issues in [thread.lock.unique.locking].

    -

    View all other issues in [thread.lock.unique.locking].

    -

    View all issues with Review status.

    -

    Discussion:

    -30.4.3.2.2 [thread.lock.unique.locking]: unique_lock::lock is -required to throw an object of type std::system_error "when the -postcondition cannot be achieved." The postcondition is owns == true, -and this is trivial to achieve. Presumably, the requirement is intended -to mean something more than that. +-8- Effects: ...

    -

    [ -Summit: -]

    - -
    -Move to open. +

    +Throws: Nothing. +

    -

    [ -Beman has volunteered to provide proposed wording. -]

    +

    +Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7: +

    -

    [ -2009-07-21 Beman added wording to address 30.2.2 [thread.req.exception] -in response to the Frankfurt notes in 859. -]

    +
    +
    void notify_one();
+
    +

    +-6- Effects: ... +

    +

    +Throws: Nothing. +

    +
    +
    void notify_all();
+
    -

    Proposed resolution:

    +

    +-7- Effects: ... +

    -

    Change Exceptions 30.2.2 [thread.req.exception] as indicated:

    -
    -

    Some functions described in this Clause are specified to throw exceptions of -type system_error (19.5.5). Such exceptions shall be thrown if -any of the Error conditions are detected or a call to an operating -system or other underlying API results in an error that prevents the library -function from satisfying its postconditions or from returning a meaningful -value meeting its specifications. Nevertheless, failure to -allocate storage shall be reported as described in [res.on.exception.handling].

    +

    +Throws: Nothing. +

    -

    Change thread assignment 30.3.1.4 [thread.thread.assign], join(), -paragraph 8 as indicated:

    -
    -

    Throws: std::system_error when the postconditions cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change thread assignment 30.3.1.4 [thread.thread.assign], detach(), paragraph -13 as indicated:

    -
    -

    Throws: std::system_error when the effects or -postconditions cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], paragraph -11, as indicated:

    -
    -

    Throws: std::system_error when the effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], -paragraph 3, as indicated:

    -
    +
    +

    1090. Missing description of packaged_task member swap, missing non-member swap

    +

    Section: 30.6.10 [futures.task] Status: Tentatively Ready + Submitter: Daniel Krügler Opened: 2009-03-22 Last modified: 2009-10-26

    +

    View all issues with Tentatively Ready status.

    +

    Discussion:

    +

    +Class template packaged_task in 30.6.10 [futures.task] shows a member swap +declaration, but misses to +document it's effects (No prototype provided). Further on this class +misses to provide a non-member +swap. +

    -

    Throws: std::system_error when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], -paragraph 8, as indicated:

    -
    +

    [ +Batavia (2009-05): +]

    -

    Throws: std::system_error when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], -paragraph 13, as indicated:

    - -

    Throws: std::system_error when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    +

    +Alisdair notes that paragraph 2 of the proposed resolution has already been +applied in the current Working Draft. +

    +

    +We note a pending future-related paper by Detlef; +we would like to wait for this paper before proceeding. +

    +

    +Move to Open. +

    -

    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], -paragraph 18, as indicated:

    -
    -

    Throws: std::system_error when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change unique_lock locking 30.4.3.2.2 [thread.lock.unique.locking], -paragraph 22, as indicated:

    -
    +

    [ +2009-05-24 Daniel removed part 2 of the proposed resolution. +]

    -

    Throws: std::system_error when the postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change Function call_once 30.4.5.2 [thread.once.callonce], paragraph 4, as -indicated

    -
    -

    Throws: std::system_error when the effects cannot be achieved an exception is required (30.2.2 [thread.req.exception]), - or any exception thrown by func.

    -
    -

    Change Class condition_variable 30.5.1 [thread.condition.condvar], -paragraph 12, as indicated:

    -
    -

    Throws: std::system_error when the effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change Class condition_variable 30.5.1 [thread.condition.condvar], -paragraph 19, as indicated:

    -
    +

    [ +2009-10 post-Santa Cruz: +]

    -

    Throws: std::system_error when the effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], -paragraph 10, as indicated:

    -
    -

    Throws: std::system_error when the effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    -

    Change Class condition_variable_any 30.5.2 [thread.condition.condvarany], -paragraph 16, as indicated:

    - -

    Throws: std::system_error when the returned value, effects, or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    +Move to Tentatively Ready, removing bullet 3 from the proposed +resolution but keeping the other two bullets.
    -

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been -applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as -indicated:

    -
    -
    template <class Rep, class Period> 
-bool wait_for(unique_lock<mutex>& lock, 
-              const chrono::duration<Rep, Period>& rel_time);
    -
    ...
    - -

    Throws: std::system_error when the effects or -postcondition cannot be achieved an exception is required ([thread.req.exception]).

    -
    -

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been -applied to the working paper, change Change 30.5.1 [thread.condition.condvar] as -indicated:

    -
    -
    template <class Rep, class Period, class Predicate> 
-  bool wait_for(unique_lock<mutex>& lock, 
-                const chrono::duration<Rep, Period>& rel_time, 
-                Predicate pred);
    - 
    ...
    -

    Throws: std::system_error when the effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    -
    +

    Proposed resolution:

    +
      +
    1. +

      +In 30.6.10 [futures.task], immediately after the definition of class +template packaged_task add: +

      +
      
+template<class R, class... Argtypes>
+void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&);
+
+
      +
      2. +
    -

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been -applied to the working paper, change 30.5.2 [thread.condition.condvarany] as -indicated:

    -
    -
    template <class Lock, class Rep, class Period> 
-  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
    - 
    ...
    +
      -

      Throws: std::system_error when the returned value, effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

      -
    +
  • +

    +At the end of 30.6.10 [futures.task] (after p. 20), add add the following +prototype description: +

    -

    Assuming issue 859, Monotonic Clock is Conditionally Supported?, has been -applied to the working paper, change 30.5.2 [thread.condition.condvarany] as -indicated:

    +
    
+template<class R, class... Argtypes>
+void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y);
+
    -
    template <class Lock, class Rep, class Period, class Predicate> 
-  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
    - 
    ...
    - -

    Throws: std::system_error when the returned value, effects or -postcondition cannot be achieved an exception is required (30.2.2 [thread.req.exception]).

    +

    +Effects: x.swap(y) +

    +

    +Throws: Nothing. +

    - +
    +
    • +
    -

    963. Various threading bugs #13

    -

    Section: 30.3.1.5 [thread.thread.member] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22

    -

    View other active issues in [thread.thread.member].

    -

    View all other issues in [thread.thread.member].

    +

    1093. Multiple definitions for random_shuffle algorithm

    +

    Section: 25.3.12 [alg.random.shuffle] Status: Open + Submitter: Alisdair Meredith Opened: 2009-03-22 Last modified: 2009-10-26

    +

    View all other issues in [alg.random.shuffle].

    View all issues with Open status.

    Discussion:

    +

    -30.3.1.5 [thread.thread.member]: thread::detach is required to -throw an exception if the thread is "not a detachable thread". -"Detachable" is never defined. +There are a couple of issues with the declaration of the random_shuffle +algorithm accepting a random number engine.

    -

    [ -Howard adds: -]

    - - -
    -Due to a mistake on my part, 3 proposed resolutions appeared at approximately -the same time. They are all three noted below in the discussion. -
    +
      +
    1. +The Iterators must be shuffle iterators, yet this requirement is missing. +
      2. +
    2. +The RandomNumberEngine concept is now provided by the random number +library +(n2836) +and the placeholder should be removed. +
      3. +

    [ -Summit, proposed resolution: +2009-05-02 Daniel adds: ]

    -In 30.3.1.5 [thread.thread.member] change: +this issue completes adding necessary requirement to the +third new random_shuffle overload. The current suggestion is:

    -
    void detach();
-
    -
    -

    ...

    -

    -14- Error conditions:

    -
      -
    • no_such_process -- if the thread is not a valid thread.
      • -
    • invalid_argument -- if the thread is not a detachable joinable thread.
      • -
    -
    - -
    - -
    - -

    [ -Post Summit, Jonathan Wakely adds: -]

    - +
    template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
+requires ShuffleIterator<Iter>
+void random_shuffle(Iter first, Iter last, Rand&& g);
+
    -

    -A thread is detachable if it is joinable. As we've defined joinable, -we can just use that. +IMO this is still insufficient and I suggest to add the requirement

    +
    Convertible<Rand::result_type, Iter::difference_type>
+

    -This corresponds to the pthreads specification, where pthread_detach -fails if the thread is not joinable: +to the list (as the two other overloads already have).

    -
    -EINVAL: The implementation has detected that the value specified by -thread does not refer to a joinable thread. -
    +

    -Jonathan recommends this proposed wording: +Rationale:

    +

    -In 30.3.1.5 [thread.thread.member] change: +Its true that this third overload is somewhat different from the remaining +two. Nevertheless we know from UniformRandomNumberGenerator, that +it's result_type is an integral type and that it satisfies +UnsignedIntegralLike<result_type>. +

    +

    +To realize it's designated task, the algorithm has to invoke the +Callable aspect of g and needs to perform some algebra involving +it's min()/max() limits to compute another index value that +at this point is converted into Iter::difference_type. This is so, +because 24.2.5 [random.access.iterators] uses this type as argument +of it's algebraic operators. Alternatively consider the equivalent +iterator algorithms in 24.4.4 [iterator.operations] with the same result. +

    +

    +This argument leads us to the conclusion that we also need +Convertible<Rand::result_type, Iter::difference_type> here.

    - -
    void detach();
-
    -
    -

    ...

    -

    -14- Error conditions:

    -
      -
    • ...
      • -
    • invalid_argument -- not a detachable joinable thread.
      • -
    -
    -

    [ -Post Summit, Anthony Williams adds: +Batavia (2009-05): ]

    -

    -This is covered by the precondition that joinable() be true. +Alisdair notes that point (ii) has already been addressed.

    -Anthony recommends this proposed wording: +We agree with the proposed resolution to point (i) +with Daniel's added requirement.

    - -

    -In 30.3.1.5 [thread.thread.member] change: +Move to Review.

    +
    + +

    [ +2009-06-05 Daniel updated proposed wording as recommended in Batavia. +]

    + + +

    [ +2009-07-28 Alisdair adds: +]

    + -
    void detach();
-
    -

    ...

    -

    -14- Error conditions:

    -
      -
    • ...
      • -
    • invalid_argument -- not a detachable thread.
      • -
    +Revert to Open, with a note there is consensus on direction but the +wording needs updating to reflect removal of concepts.
    -
    +

    [ +2009-10 post-Santa Cruz: +]

    -
    +
    +Leave Open, Walter to work on it.

    Proposed resolution:

    +

    +Change in [algorithms.syn] and 25.3.12 [alg.random.shuffle]: +

    + +
    concept UniformRandomNumberGenerator<typename Rand> { }
+template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
+  requires ShuffleIterator<Iter> &&
+  Convertible<Rand::result_type, Iter::difference_type>
+  void random_shuffle(Iter first, Iter last, Rand&& g);
+
    +
    -

    964. Various threading bugs #14

    -

    Section: 30.5.2 [thread.condition.condvarany] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-03-22

    -

    View all issues with Open status.

    +

    1094. Response to JP 65 and JP 66

    +

    Section: 27.5.4.3 [iostate.flags] Status: Ready + Submitter: P.J. Plauger Opened: 2009-03-24 Last modified: 2009-10-20

    +

    View all other issues in [iostate.flags].

    +

    View all issues with Ready status.

    Discussion:

    +

    Addresses JP 65 and JP 66

    +

    -The requirements for the constructor for condition_variable has several -error conditions, but the requirements for the constructor for -condition_variable_any has none. Is this difference intentional? +Switch from "unspecified-bool-type" to "explicit operator bool() const". +

    + +

    +Replace operator unspecified-bool-type() const;" with explicit operator bool() const;

    [ -Summit: +Batavia (2009-05): ]

    -
    -Move to open, pass to Howard. If this is intentional, a note may be -helpful. If the error conditions are to be copied from -condition_variable, this depends on LWG 965. +We agree with the proposed resolution. +Move to Review.

    [ -Post Summit Howard adds: +2009 Santa Cruz: ]

    -The original intention -(N2447) -was to let the OS return whatever errors it was going to return, and for -those to be translated into exceptions, for both -condition_variable and condition_variable_any. I have not -received any complaints about specific error conditions from vendors on -non-POSIX platforms, but such complaints would not surprise me if they surfaced. +Moved to Ready.
    +

    Proposed resolution:

    +

    +Change the synopis in 27.5.4 [ios]: +

    + +
    explicit operator unspecified-bool-type bool() const;
+
    + +

    +Change 27.5.4.3 [iostate.flags]: +

    + +
    explicit operator unspecified-bool-type bool() const;
+
    + +
    +

    +-1- Returns: !fail() If fail() then a value that will evaluate +false in a boolean context; otherwise a value that will evaluate true in +a boolean context. The value type returned shall not be convertible to +int. +

    +

    +[Note: This conversion can be used in contexts where a bool is expected +(e.g., an if condition); however, implicit conversions (e.g., +to int) that can occur with bool are not allowed, +eliminating some sources of user error. One possible implementation +choice for this type is pointer-to-member. -- end note] +

    +
    +
    + +
    -

    966. Various threading bugs #16

    -

    Section: 30.5.1 [thread.condition.condvar] Status: Open - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-08-01

    -

    View other active issues in [thread.condition.condvar].

    -

    View all other issues in [thread.condition.condvar].

    -

    View all issues with Open status.

    +

    1095. Shared objects and the library wording unclear

    +

    Section: 17.6.3.10 [res.on.objects] Status: Ready + Submitter: Beman Dawes Opened: 2009-03-27 Last modified: 2009-10-21

    +

    View all issues with Ready status.

    Discussion:

    -30.5.1 [thread.condition.condvar]: condition_variable::wait and -condition_variable::wait_until both have a postcondition that lock is -locked by the calling thread, and a throws clause that requires throwing -an exception if this postcondition cannot be achieved. How can the -implementation detect that this lock can never be obtained? +N2775, +Small library thread-safety revisions, among other changes, removed a note from +17.6.3.10 [res.on.objects] that read:

    -

    [ -Summit: -]

    - -
    -Move to open. Requires wording. Agreed this is an issue, and the -specification should not require detecting deadlocks. +[Note: This prohibition against concurrent non-const access means that +modifying an object of a standard library type shared between threads +without using a locking mechanism may result in a data race. --end note.]
    +

    +That resulted in wording which is technically correct but can only be +understood by reading the lengthy and complex 17.6.4.8 [res.on.data.races] +Data race avoidance. This has the effect of making +17.6.3.10 [res.on.objects] unclear, and has already resulted in a query +to the LWG reflector. See c++std-lib-23194. +

    +

    [ -2009-08-01 Howard provides wording. +Batavia (2009-05): ]

    -

    -The proposed wording is inspired by the POSIX spec which says: +The proposed wording seems to need a bit of tweaking +("really bad idea" isn't quite up to standardese). +We would like feedback +as to whether the original Note's removal was intentional.

    - -
    -
    -
    [EINVAL]
    -
    The value specified by cond or mutex is invalid.
    -
    [EPERM]
    -
    The mutex was not owned by the current thread at the time of the call.
    -
    -
    -

    -I do not believe [EINVAL] is possible without memory corruption (which we don't -specify). [EPERM] is possible if this thread doesn't own the mutex, which is -listed as a precondition. "May" is used instead of "Shall" because not all -OS's are POSIX. +Change the phrase "is a really bad idea" +to "risks undefined behavior" and +move to Review status.

    +

    [ +2009-10 Santa Cruz: +]

    + + +
    +Note: Change to read: "Modifying...", Delete 'thus', move to Ready +
    +

    Proposed resolution:

    -Change 30.5.1 [thread.condition.condvar] p12, p19 and -30.5.2 [thread.condition.condvarany] p10, p16: +Change 17.6.3.10 [res.on.objects] as indicated:

    -Throws: May throw std::system_error - -if a precondition is not met. - -when the effects or postcondition -cannot be achieved. +

    +The behavior of a program is undefined if calls to standard library +functions from different threads may introduce a data race. The +conditions under which this may occur are specified in 17.6.4.7. +

    +

    +[Note: Modifying an object of a standard library type shared between +threads risks undefined behavior unless objects of the type are explicitly +specified as being sharable without data races or the user supplies a +locking mechanism. --end note] +

    @@ -20738,176 +17312,90 @@ cannot be achieved.
    -

    967. Various threading bugs #17

    -

    Section: 30.3.1.2 [thread.thread.constr] Status: Review - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-06-27

    -

    View other active issues in [thread.thread.constr].

    -

    View all other issues in [thread.thread.constr].

    -

    View all issues with Review status.

    +

    1097. #define __STDCPP_THREADS

    +

    Section: 18.2 [support.types] Status: Ready + Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-10-21

    +

    View all other issues in [support.types].

    +

    View all issues with Ready status.

    Discussion:

    +

    Addresses DE 18

    +

    -the error handling for the constructor for condition_variable -distinguishes lack of memory from lack of other resources, but the error -handling for the thread constructor does not. Is this difference -intentional? +Freestanding implementations do not (necessarily) have + support for multiple threads (see 1.10 [intro.multithread]). + Applications and libraries may want to optimize for the + absence of threads. I therefore propose a preprocessor + macro to indicate whether multiple threads can occur.

    -

    [ -Beman has volunteered to provide proposed wording. -]

    - - - -

    Proposed resolution:

    -

    Change Exceptions 30.2.2 [thread.req.exception] as indicated:

    -
    -

    Some functions described in this Clause are -specified to throw exceptions of type system_error (19.5.5). Such exceptions -shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API -results in an error that prevents the library function from meeting its specifications. -[Note: See 17.6.4.10 [res.on.exception.handling] for exceptions thrown to report -storage allocation failures. --end -note]

    - -
    - -

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], -paragraph 4, as indicated:

    -
    - -

    Error conditions:

    -
    - -
      -
    • not_enough_memory — if there is not enough memory to construct -the mutex object.
      • - -
    • resource_unavailable_try_again — if any native handle type -manipulated is not available.
      • - -
    • operation_not_permitted — if the thread does not have the -necessary permission to change the state of the mutex object.
      • - -
    • device_or_resource_busy — if any native handle type -manipulated is already locked.
      • - -
    • invalid_argument — if any native handle type manipulated as -part of mutex construction is incorrect.
      • -
    -
    -
    - -

    Change Class condition_variable 30.5.1 [thread.condition.condvar], -default constructor, as indicated:

    -
    -

    condition_variable();

    -
    -

    Effects: Constructs an object of type condition_variable.

    -

    Throws: std::system_error when an exception is required (30.2.2 [thread.req.exception]).

    -

    Error conditions:

    -
    -
      -
    • not_enough_memory &msash; if a memory limitation prevents - initialization.
      • -
    • resource_unavailable_try_again &msash; if some non-memory - resource limitation prevents initialization.
      • -
    • device_or_resource_busy &msash; if attempting to initialize a - previously-initialized but as of yet undestroyed condition_variable.
      • -
    -
    -
    -
    - - - +

    +There is ample prior implementation experience for this + feature with various spellings of the macro name. For + example, gcc implicitly defines _REENTRANT + if multi-threading support is selected on the compiler + command-line. +

    +

    +While this is submitted as a library issue, it may be more + appropriate to add the macro in 16.8 cpp.predefined in the + core language. +

    -
    -

    968. Various threading bugs #18

    -

    Section: 30.4.1 [thread.mutex.requirements] Status: Review - Submitter: Pete Becker Opened: 2009-01-07 Last modified: 2009-06-27

    -

    View other active issues in [thread.mutex.requirements].

    -

    View all other issues in [thread.mutex.requirements].

    -

    View all issues with Review status.

    -

    Discussion:

    -30.4.1 [thread.mutex.requirements]: several functions are -required to throw exceptions "if the thread does not have the necessary -permission ...". "The necessary permission" is not defined. +See also +N2693.

    [ -Summit: +Batavia (2009-05): ]

    -Move to open. +

    +We agree with the issue, and believe it is properly a library issue. +

    +

    +We prefer that the macro be conditionally defined +as part of the <thread> header. +

    +

    +Move to Review. +

    -

    [ -Beman has volunteered to provide proposed wording. +2009-10 Santa Cruz: ]

    - -

    Proposed resolution:

    - - -

    Change Exceptions 30.2.2 [thread.req.exception] as indicated:

    -
    -

    Some functions described in this Clause are -specified to throw exceptions of type system_error (19.5.5). Such exceptions -shall be thrown if any of the Error conditions are detected or a call to an operating system or other underlying API -results in an error that prevents the library function from meeting its specifications. -[Note: See 17.6.4.10 [res.on.exception.handling] for exceptions thrown to report -storage allocation failures. —end -note]

    - -

    [Example:

    -
    - -

    A function in this clause that is specified to throw exceptions of type -system_error and specifies Error conditions that include -operation_not_permitted for a thread that does not have the privilege to -perform the operation. During the execution of this function, an errno -of EPERM is reported by a POSIX API call used by the -implementation. Since POSIX specifies an errno of EPERM -when "the caller does not have the privilege to perform the operation", -the implementation maps EPERM  to an error_condition -of operation_not_permitted (19.5 [syserr]) and an exception of type -system_error is thrown.

    - +Move to Ready.
    -

    —end example]

    - -

    Editorial note: For the sake of exposition, -the existing text above is shown with the changes proposed in issues 962 and 967. The -proposed additional example is independent of whether or not the 962 and 967 -proposed resolutions are accepted.

    - -
    -

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], -paragraph 4, as indicated:

    +

    Proposed resolution:

    +

    +Insert a new subsection before 18.2 [support.types], entitled +"Feature Macros" (support.macros): +

    - -

    — operation_not_permitted — if the thread does not have the -necessary permission to change the state of the mutex object privilege to perform the operation.

    - -
    - -

    Change Mutex requirements 30.4.1 [thread.mutex.requirements], -paragraph 12, as indicated:

    - +

    +The standard library defines the following macros; no explicit +prior inclusion of any header file is necessary. +

    - -

    — operation_not_permitted — if the thread does not have the -necessary permission to change the state of the mutex privilege to perform the operation.

    - +
    +
    __STDCPP_THREADS
    +
    +The macro __STDCPP_THREADS shall be defined if and only if a + program can have more than one thread of execution (1.10 [intro.multithread]). +If the macro is defined, it shall have the same + value as the predefined macro __cplusplus (16.8 [cpp.predefined]). +
    +
    +
    @@ -20916,558 +17404,442 @@ paragraph 12, as indicated:

    -

    971. Spurious diagnostic conversion function

    -

    Section: 19.5.2.6 [syserr.errcode.nonmembers] Status: Tentatively NAD - Submitter: Beman Dawes Opened: 2009-01-19 Last modified: 2009-07-22

    -

    View all issues with Tentatively NAD status.

    +

    1098. definition of get_pointer_safety()

    +

    Section: 20.8.15.6 [util.dynamic.safety] Status: Ready + Submitter: Jens Maurer Opened: 2009-04-03 Last modified: 2009-10-23

    +

    View all other issues in [util.dynamic.safety].

    +

    View all issues with Ready status.

    Discussion:

    +

    Addresses DE 18

    +

    -Anthony Williams raised the question in c++std-lib-22987 "why is there -std::make_error_code(std::errc)? What purpose does this serve?" + In 20.8.15.6 [util.dynamic.safety], get_pointer_safety() purports +to define behavior for + non-safely derived pointers (3.7.4.3 [basic.stc.dynamic.safety]). However, + the cited core-language section in paragraph 4 specifies undefined behavior + for the use of such pointer values. This seems an unfortunate near-contradiction. + I suggest to specify the term relaxed pointer safety in + the core language section and refer to it from the library description. + This issue deals with the library part, the corresponding core issue (c++std-core-13940) + deals with the core modifications.

    +

    -The function make_error_code(errc e) is not required, since -make_error_condition(errc e) is the function that is needed for errc -conversions. make_error_code(errc e) appears to be a holdover from my -initial confusion over the distinction between POSIX and operating -systems that conform to the POSIX spec. +See also +N2693.

    -

    [ -Post Summit: -]

    - - -
    -Recommend Review. -
    -

    [ Batavia (2009-05): ]

    -The designer of the facility (Christopher Kohlhoff) -strongly disagrees that there is an issue here, -and especially disagrees with the proposed resolution. -Bill would prefer to be conservative and not apply this proposed resolution. -Move to Open, and recommend strong consideration for NAD status. +

    +We recommend if this issue is to be moved, +the issue be moved concurrently with the cited Core issue. +

    +

    +We agree with the intent of the proposed resolution. +We would like input from garbage collection specialists. +

    +

    +Move to Open. +

    [ -2009-05-21 Beman adds: +2009-10 Santa Cruz: ]

    -My mistake. Christopher and Bill are correct and the issue should be -NAD. The function is needed by users. +The core issue is 853 and is in Ready status.
    -

    [ -2009-07-21 Christopher Kohlhoff adds rationale for make_error_code: -]

    - - -
    -

    -Users (and indeed library implementers) may need to use the -errc codes in portable code. For example: -

    - -
    void do_foo(error_code& ec)
-{
-#if defined(_WIN32)
-  // Windows implementation ...
-#elif defined(linux)
-  // Linux implementation ...
-#else
-  // do_foo not supported on this platform
-  ec = make_error_code(errc::not_supported);
-#endif
-}
-
    -

    Proposed resolution:

    -Change System error support 19.5 [syserr], Header <system_error> -synopsis, as indicated: +In 20.8.15.6 [util.dynamic.safety] p16, replace the description of +get_pointer_safety() with:

    -
    error_code make_error_code(errc e);
-error_condition make_error_condition(errc e);
-
    - +

    -Delete from Class error_code non-member functions -19.5.2.6 [syserr.errcode.nonmembers]: +pointer_safety get_pointer_safety();

    - -
    error_code make_error_code(errc e);
-
    -Returns: error_code(static_cast<int>(e), -generic_category). -
    -
    - - - - - - -
    -

    974. duration<double> should not implicitly convert to duration<int>

    -

    Section: 20.9.3.1 [time.duration.cons] Status: Open - Submitter: Howard Hinnant Opened: 2009-01-21 Last modified: 2009-08-01

    -

    View all issues with Open status.

    -

    Discussion:

    -The following code should not compile because it involves implicit truncation -errors (against the design philosophy of the duration library). -

    - -
    duration<double> d(3.5);
-duration<int> i = d;  // implicit truncation, should not compile
-
    - -

    -This intent was codified in the example implementation which drove this proposal -but I failed to accurately translate the code into the specification in this -regard. +Returns: an enumeration value indicating the implementation's treatment +of pointers that are not safely derived (3.7.4.3). Returns +pointer_safety::relaxed if pointers that are not safely derived will be +treated the same as pointers that are safely derived for the duration of +the program. Returns pointer_safety::preferred if pointers that are not +safely derived will be treated the same as pointers that are safely +derived for the duration of the program but allows the implementation to +hint that it could be desirable to avoid dereferencing pointers that are +not safely derived as described. [Example: pointer_safety::preferred +might be returned to detect if a leak detector is running to avoid +spurious leak reports. -- end note] Returns pointer_safety::strict if +pointers that are not safely derived might be treated differently than +pointers that are safely derived.

    +

    +Returns: Returns pointer_safety::strict if the implementation has + strict pointer safety (3.7.4.3 [basic.stc.dynamic.safety]). It is + implementation-defined whether get_pointer_safety returns + pointer_safety::relaxed or pointer_safety::preferred if the + implementation has relaxed pointer safety + (3.7.4.3 [basic.stc.dynamic.safety]).Footnote +

    -

    [ -Batavia (2009-05): -]

    +

    +Throws: nothing +

    -
    -

    -We agree with the proposed resolution. -

    -

    -Move to Tentatively Ready. +

    +Footnote) pointer_safety::preferred might be returned to indicate to the + program that a leak detector is running so that the program can avoid + spurious leak reports. +

    -
    - -

    [ -2009-07 Frankfurt -]

    - -
    -Moved from Tentatively Ready to Open only because the wording needs to be -improved for enable_if type constraining, possibly following Robert's -formula.
    - -

    [ -2009-08-01 Howard adds: -]

    +
    -
    -Addressed by 1177. -
    -

    Proposed resolution:

    +
    +

    1099. Various issues

    +

    Section: 17 [library] Status: Tentatively NAD + Submitter: David Abrahams Opened: 2009-03-21 Last modified: 2009-10-26

    +

    View other active issues in [library].

    +

    View all other issues in [library].

    +

    View all issues with Tentatively NAD status.

    +

    Discussion:

    -Change 20.9.3.1 [time.duration.cons], p4: +Notes

    -
    -
    template <class Rep2, class Period2> 
-  duration(const duration<Rep2, Period2>& d);
-
    +

    +[2009-03-21 Sat] p. 535 at the top we need MoveConstructible V1, +MoveConstructible V2 (where V1,V2 are defined on 539). Also make_tuple +on 550 +

    +
    --4- Requires: treat_as_floating_point<rep>::value -shall be true or both ratio_divide<Period2, -period>::type::den shall be 1 -and treat_as_floating_point<Rep2>::value -shall be false. -Diagnostic required. -[Note: This requirement prevents implicit truncation error when -converting between integral-based duration types. Such a -construction could easily lead to confusion about the value of the -duration. -- end note] -
    -
    +

    +CD-1 reads: +

    +
    template <MoveConstructible T1, MoveConstructible T2> 
+pair<V1, V2> make_pair(T1&&, T2&&); 
+
    +

    +Actually I'm guessing we need something like MoveConstructible<V1,T1>, +i.e. "V1 can be constructed from an rvalue of type T1." +

    +

    +Ditto for make_tuple +

    +
    +

    +[2009-03-21 Sat] p1183 thread ctor, and in general, we need a way to +talk about "copiable from generalized rvalue ref argument" for cases +where we're going to forward and copy. +

    +
    +

    + This issue may well be quite large. Language in para 4 about "if + an lvalue" is wrong because types aren't expressions. +

    -
    -

    976. Class template std::stack should be movable

    -

    Section: 23.3.5.3.1 [stack.defn] Status: Open - Submitter: Daniel Krügler Opened: 2009-02-01 Last modified: 2009-07-14

    -

    View all issues with Open status.

    -

    Discussion:

    +

    -The synopsis given in 23.3.5.3.1 [stack.defn] does not show up +Maybe we should define the term "move" so we can just say in the +effects, "f is moved into the newly-created thread" or something, and +agree (and ideally document) that saying "f is moved" implies

    -
    requires MoveConstructible<Cont> stack(stack&&);
-requires MoveAssignable<Cont> stack& operator=(stack&&);
+
    F x(move(f))
 
    
 
 
    
-although the other container adaptors do provide corresponding
-members.
+is required to work.  That would cover both ctors at once.
 
    
+
    -

    [ -Batavia (2009-05): -]

    +

    + p1199, call_once has all the same issues. +

    +
    +

    +[2009-03-21 Sat] p869 InputIterator pointer type should not be required +to be convertible to const value_type*, rather it needs to have a +operator-> of its own that can be used for the value type. +

    +This one is serious and unrelated to the move issue. +
    +

    -We agree with the proposed resolution. +[2009-03-21 Sat] p818 stack has the same problem with default ctor.

    -Move to Tentatively Ready. +[2009-03-21 Sat] p816 priority_queue has the same sorts of problems as queue, only more so +

    +
       requires MoveConstructible<Cont> 
+     explicit priority_queue(const Compare& x = Compare(), Cont&& = Cont()); 
+
    +

    + Don't require MoveConstructible when default constructing Cont. + Also missing semantics for move ctor.

    +

    + [2009-03-21 Sat] Why are Allocators required to be CopyConstructible as + opposed to MoveConstructible? +

    +

    + [2009-03-21 Sat] p813 queue needs a separate default ctor (Cont needn't + be MoveConstructible). No documented semantics for move c'tor. Or + *any* of its 7 ctors! +

    +

    + [2009-03-21 Sat] std::array should have constructors for C++0x, + consequently must consider move construction. +

    [ -2009-07 Frankfurt +2009-05-01 Daniel adds: ]

    -Moved from Tentatively Ready to Open only because the wording needs to be -tweaked for concepts removal. +This could be done as part of 1035, which already handles +deviation of std::array from container tables.
    - - -

    Proposed resolution:

    -In the class stack synopsis of 23.3.5.3.1 [stack.defn] insert: + [2009-03-21 Sat] p622 all messed up.

    - -
    template <ObjectType T, StackLikeContainer Cont = deque<T> > 
-  requires SameType<Cont::value_type, T> 
-        && NothrowDestructible<Cont> 
-class stack { 
-public: 
-   ...
-   requires CopyConstructible<Cont> explicit stack(const Cont&); 
-   requires MoveConstructible<Cont> explicit stack(Cont&& = Cont()); 
-   requires MoveConstructible<Cont> stack(stack&&);
-   requires MoveAssignable<Cont> stack& operator=(stack&&);
-   template <class Alloc> 
-     requires Constructible<Cont, const Alloc&> 
-     explicit stack(const Alloc&);
-   ...
-};
-
    - +

    -[Remark: This change should be done in sync with the resolution of -paper -N2819] + para 8 "implementation-defined" is the wrong term; should be "see + below" or something. +

    +

    + para 12 "will be selected" doesn't make any sense because we're not + talking about actual arg types.

    - - - - - - -
    -

    977. insert iterators inefficient for expensive to move types

    -

    Section: 24.7 [insert.iterators] Status: Open - Submitter: Howard Hinnant Opened: 2009-02-02 Last modified: 2009-05-23

    -

    View other active issues in [insert.iterators].

    -

    View all other issues in [insert.iterators].

    -

    View all issues with Open status.

    -

    Discussion:

    -The new concepts for the insert iterators mandate an extra copy when -inserting an lvalue: + paras 9-13 need to be totally rewritten for concepts.

    - -
    requires CopyConstructible<Cont::value_type>
-  back_insert_iterator<Cont>& 
-  operator=(const Cont::value_type& value);
-
    -
    --1- Effects: push_back(*container, Cont::value_type(value)); -

    -The reason is to convert value into an rvalue because the current -BackInsertionContainer concept only handles push_back-ing -rvalues: + [2009-03-21 Sat] Null pointer comparisons (p587) have all become + unconstrained. Need to fix that

    - -
    concept BackInsertionContainer<typename C> : Container<C> { 
-  void push_back(C&, value_type&&); 
-}
-
    -

    -Without the conversion of value to an rvalue, the assignment operator -fails to concept check. + [2009-03-21 Sat] mem_fun_t etc. definition doesn't match declaration. + We think CopyConstructible is the right reqt.

    -

    -A solution is to modify the BackInsertionContainer concept so that -the client can pass in the parameter type for push_back similar to -what is already done for the OutputIterator concept: + make_pair needs Constructible<V1, T1&&> requirements!

    - -
    concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
-  : Container<C> { 
-     void push_back(C&, Value); 
-}
-
    -

    -This allows the assignment operator to be adjusted appropriately: + make_tuple needs something similar

    - -
    requires BackInsertionContainer<Cont, Cont::value_type const&> &&
-         CopyConstructible<Cont::value_type>
-  back_insert_iterator<Cont>& 
-  operator=(const Cont::value_type& value);
+
    
+ tuple bug in synopsis:
+
    
+
       template <class... UTypes>
+   requires Constructible<Types, const UTypes&>...
+   template <class... UTypes>
+   requires Constructible<Types, RvalueOf<UTypes>::type>...
 
    
-
    
--1- Effects: push_back(*container, value);
-
    
+
    
+   Note: removal of MoveConstructible requirements in std::function makes
+   these routines unconstrained!
+
    
 
    
 
 
    [
-We may want to propagate this fix to other concepts such as StackLikeContainer.
+2009-05-02 Daniel adds:
 ]
    
 
 
-
    [
-Solution and wording collaborated on by Doug and Howard.
-]
    
+
    
+This part of the issue is already covered by 1077.
+
    
+
+
    
+ these unique_ptr constructors are broken [ I think this is covered in "p622 all messed up" ]
+
    
+
     unique_ptr(pointer p, implementation-defined d);
+ unique_ptr(pointer p, implementation-defined d);
+
    
+
    
+ multimap range constructor should not have MoveConstructible<value_type> requirement.
+
    
+
    
+   same with insert(..., P&&); multiset has the same issue, as do
+   unordered_multiset and unordered_multimap. Review these!
+
    
 
+

    [ Batavia (2009-05): ]

    -

    -Howard notes that "these operations behaved efficiently until concepts were added." -

    -

    -Alisdair is uncertain that the proposed resolution is syntactically correct. -

    -

    -Move to Open, and recommend the issue be deferred until after the next -Committee Draft is issued. -

    +Move to Open, pending proposed wording from Dave for further review.
    +

    [ +2009-10 post-Santa Cruz: +]

    -

    Proposed resolution:

    -

    -Change 23.2.6.1 [container.concepts.free]: -

    -
    concept FrontInsertionContainer<typename C, typename Value = C::value_type&&>
-    : Container<C> { 
-  void push_front(C&, value_type&& Value); 
-
-  axiom FrontInsertion(C c, value_type Value x) { 
-    x == (push_front(c, x), front(c)); 
-  } 
-}
-
    - -

    ...

    - -
    concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
-    : Container<C> { 
-  void push_back(C&, value_type&& Value); 
-}
-
    - -

    ...

    - -
    concept InsertionContainer<typename C, typename Value = C::value_type&&>
-    : Container<C> { 
-  iterator insert(C&, const_iterator, value_type&& Value); 
+Tentatively NAD.  We are not sure what has been addressed and what hasn't.
+Recommend closing unless someone sorts this out into something more readable.
+
    - axiom Insertion(C c, const_iterator position, value_type Value v) { - v == *insert(c, position, v); - } -} - -
    +

    Proposed resolution:

    -Change 23.2.6.2 [container.concepts.member]:

    -
    -
    auto concept MemberFrontInsertionContainer<typename C, typename Value = C::value_type&&>
-    : MemberContainer<C> { 
-  void C::push_front(value_type&& Value); 
-
-  axiom MemberFrontInsertion(C c, value_type Value x) { 
-    x == (c.push_front(x), c.front()); 
-  } 
-}
-
    - -

    ...

    - -
    auto concept MemberBackInsertionContainer<typename C, typename Value = C::value_type&&>
-    : MemberContainer<C> { 
-  void C::push_back(value_type&& Value); 
-}
-
    -

    ...

    -
    auto concept MemberInsertionContainer<typename C, typename Value = C::value_type&&>
-    : MemberContainer<C> { 
-  iterator C::insert(const_iterator, value_type&& Value); 
 
-  axiom MemberInsertion(C c, const_iterator position, value_type Value v) { 
-    v == *c.insert(position, v); 
-  } 
-}
-
    -
    +
    +

    1100. auto_ptr to unique_ptr conversion

    +

    Section: 20.8.14.2.1 [unique.ptr.single.ctor] Status: Ready + Submitter: Howard Hinnant Opened: 2009-04-25 Last modified: 2009-10-21

    +

    View other active issues in [unique.ptr.single.ctor].

    +

    View all other issues in [unique.ptr.single.ctor].

    +

    View all issues with Ready status.

    +

    Discussion:

    -Change 23.2.6.3 [container.concepts.maps]: +Message c++std-lib-23182 led to a discussion in which several people +expressed interest in being able to convert an auto_ptr to a +unique_ptr without the need to call release. Below is +wording to accomplish this.

    -
    -
    template <MemberFrontInsertionContainer C, typename Value = C::value_type&&> 
-concept_map FrontInsertionContainer<C, Value> { 
-  typedef Container<C>::value_type value_type;
+
    [
+Batavia (2009-05):
+]
    
 
-  void push_front(C& c, value_type&& Value v) { c.push_front(static_cast<value_type&& Value>(v)); } 
-}
-
    +
    +

    +Pete believes it not a good idea to separate parts of a class's definition. +Therefore, if we do this, +it should be part of unique-ptr's specification. +

    +

    +Alisdair believes the lvalue overload may be not necessary. +

    +

    +Marc believes it is more than just sugar, +as it does ease the transition to unique-ptr. +

    +

    +We agree with the resolution as presented. +Move to Tentatively Ready. +

    +
    -

    ...

    +

    [ +2009-07 Frankfurt +]

    -
    template <MemberBackInsertionContainer C, typename Value = C::value_type&&> 
-concept_map BackInsertionContainer<C, Value> { 
-  typedef Container<C>::value_type value_type;
 
-  void push_back(C& c, value_type&& Value v) { c.push_back(static_cast<value_type&& Value>(v)); } 
-}
-
    +
    +Moved from Tentatively Ready to Open only because the wording needs to be +tweaked for concepts removal. +
    -

    ...

    +

    [ +2009-08-01 Howard deconceptifies wording: +]

    -
    template <MemberInsertionContainer C, typename Value = C::value_type&&> 
-concept_map InsertionContainer<C, Value> { 
-  typedef Container<C>::value_type value_type;
-  Container<C>::iterator insert(C& c, Container<C>::const_iterator i, value_type&& Value v) 
-  { return c.insert(i, static_cast<value_type&& Value>(v)); } 
-}
-
    +
    +I also moved the change from D.10 [depr.auto.ptr] +to 20.8.14.2 [unique.ptr.single] per the Editor's request +in Batavia (as long as I was making changes anyway). Set back +to Review.
    -

    -Change 24.7.1 [back.insert.iterator]: -

    - -
    template <BackInsertionContainer Cont> 
-class back_insert_iterator {
-  ...
-  requires BackInsertionContainer<Cont, const Cont::value_type&>
-           CopyConstructible<Cont::value_type>
-    back_insert_iterator<Cont>& 
-      operator=(const Cont::value_type& value);
-  ...
-
    +

    [ +2009-10 Santa Cruz: +]

    -

    -Change 24.7.2.2 [back.insert.iter.op=]: -

    -
    requires BackInsertionContainer<Cont, const Cont::value_type&>
-         CopyConstructible<Cont::value_type>
-  back_insert_iterator<Cont>& 
-    operator=(const Cont::value_type& value);
-
    -
    --1- Effects: push_back(*container, Cont::value_type(value)); -
    +Move to Ready.
    + + +

    Proposed resolution:

    -Change 24.7.3 [front.insert.iterator]: +Add to 20.8.14.2 [unique.ptr.single]:

    -
    template <FrontInsertionContainer Cont> 
-class front_insert_iterator {
-  ...
-  requires FrontInsertionContainer<Cont, const Cont::value_type&>
-           CopyConstructible<Cont::value_type>
-    front_insert_iterator<Cont>& 
-      operator=(const Cont::value_type& value);
-  ...
+
    template <class T, class D>
+class unique_ptr
+{
+public:
+    template <class U>
+      unique_ptr(auto_ptr<U>& u);
+    template <class U>
+      unique_ptr(auto_ptr<U>&& u);
+};
 
    
 
 
    
-Change 24.7.4.2 [front.insert.iter.op=]:
+Add to 20.8.14.2.1 [unique.ptr.single.ctor]:
 
    
 
-
    
-
    requires FrontInsertionContainer<Cont, const Cont::value_type&>
-         CopyConstructible<Cont::value_type>
-  front_insert_iterator<Cont>& 
-    operator=(const Cont::value_type& value);
+
    template <class U>
+  unique_ptr(auto_ptr<U>& u);
+template <class U>
+  unique_ptr(auto_ptr<U>&& u);
 
    
 
    
--1- Effects: push_front(*container, Cont::value_type(value));
-
    
-
    
-
 
    
-Change 24.7.5 [insert.iterator]:
+Effects: Constructs a unique_ptr with u.release().
 
    
 
-
    template <InsertionContainer Cont> 
-class insert_iterator {
-  ...
-  requires InsertionContainer<Cont, const Cont::value_type&>
-           CopyConstructible<Cont::value_type>
-    insert_iterator<Cont>& 
-      operator=(const Cont::value_type& value);
-  ...
-
    
+
    
+Postconditions: get() ==  the value u.get() had before
+the construciton, modulo any required offset adjustments resulting from the cast from
+U* to T*.  u.get() == nullptr.
+
    
 
 
    
-Change 24.7.6.2 [insert.iter.op=]:
+Throws: nothing.
 
    
 
-
    
-
    requires InsertionContainer<Cont, const Cont::value_type&>
-         CopyConstructible<Cont::value_type>
-  insert_iterator<Cont>& 
-    operator=(const Cont::value_type& value);
-
    
-
    
 
    
--1- Effects:
+Remarks: U* shall be implicitly convertible to T* and
+D shall be the same type as default_delete<T>, else these
+constructors shall not participate in overload resolution.
 
    
-
    iter = insert(*container, iter, Cont::value_type(value)); 
-++iter;
-
    
 
    
 
    
 
@@ -21477,21 +17849,26 @@ Change 24.7.6.2 [insert.iter.op=]:
 
 
 
    
-
    978. Hashing smart pointers
    
-
    Section: 20.7.17 [unord.hash] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-02-02  Last modified: 2009-07-28
    
-
    View other active issues in [unord.hash].
    
-
    View all other issues in [unord.hash].
    
-
    View all issues with Open status.
    
+
    1104. basic_ios::move should accept lvalues
    
+
    Section: 27.5.4.2 [basic.ios.members] Status: Ready
+ Submitter: Howard Hinnant Opened: 2009-04-25  Last modified: 2009-10-20
    
+
    View other active issues in [basic.ios.members].
    
+
    View all other issues in [basic.ios.members].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
-I don't see an open issue on supporting std::hash for smart pointers
-(unique_ptr and shared_ptr at least).
+With the rvalue reference changes in
+N2844
+basic_ios::move no longer has the most convenient signature:
 
    
+
+
    void move(basic_ios&& rhs);
+
    
+
 
    
-It seems reasonable to at least expect support for the smart
-pointers, especially as they support comparison for use in ordered
-associative containers.
+This signature should be changed to accept lvalues.  It does not need to be
+overloaded to accept rvalues.  This is a special case that only derived clients
+will see.  The generic move still needs to accept rvalues.
 
    
 
 
    [
@@ -21500,100 +17877,124 @@ Batavia (2009-05):
 
 
    
 
    
-Howard points out that the client can always supply a custom hash function.
-
    
-
    
-Alisdair replies that the smart pointer classes are highly likely
-to be frequently used as hash keys.
-
    
-
    
-Bill would prefer to be conservative.
+Tom prefers, on general principles, to provide both overloads.
+Alisdair agrees.
 
    
 
    
-Alisdair mentions that this issue may also be viewed as a subissue or
-duplicate of issue 1025.
+Howard points out that there is no backward compatibility issue
+as this is new to C++0X.
 
    
 
    
-Move to Open, and recommend the issue be deferred until after the next
-Committee Draft is issued.
+We agree that both overloads should be provided,
+and Howard will provide the additional wording.
+Move to Open.
 
    
 
    
 
 
    [
-2009-05-31 Peter adds:
+2009-05-23 Howard adds:
 ]
    
 
 
 
    
-
    
-Howard points out that the client can always supply a custom hash function.
-
    
-
    
-Not entirely true. The client cannot supply the function that hashes the
-address of the control block (the equivalent of the old operator<, now
-proudly carrying the awkward name of 'owner_before'). Only the
-implementation can do that, not necessarily via specializing hash<>, of
-course.
-
    
-
    
-This hash function makes sense in certain situations for shared_ptr
-(when one needs to switch from set/map using ownership ordering to
-unordered_set/map) and is the only hash function that makes sense for
-weak_ptr.
-
    
+Added overload, moved to Review.
 
    
 
 
    [
-2009-07-28 Alisdair provides wording.
+2009 Santa Cruz:
 ]
    
 
 
+
    
+Move to Ready.
+
    
+
 
 
 
    Proposed resolution:
    
 
    
-Add the following declarations to the synopsis of <memory>
-in 20.8 [memory]
+Add a signature to the existing prototype in the synopsis of 27.5.4 [ios]
+and in 27.5.4.2 [basic.ios.members]:
 
    
 
-
    // 20.8.10.X hash support
-template <class T> struct hash;
-template <class T, class D> struct hash<unique_ptr<T,D>>;
-template <class T> struct hash<shared_ptr<T>>;
+
    void move(basic_ios& rhs);
+void move(basic_ios&& rhs);
 
    
 
+
+
+
+
+
    
+
    1106. Multiple exceptions from connected shared_future::get()?
    
+
    Section: 30.6.7 [future.shared_future] Status: Open
+ Submitter: Thomas J. Gritzan Opened: 2009-04-03  Last modified: 2009-05-23
    
+
    View all other issues in [future.shared_future].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-Add a new subclause 20.8.10.X hash support
+It is not clear, if multiple threads are waiting in a 
+shared_future::get() call, if each will rethrow the stored exception.
 
    
-
-
    
 
    
-20.8.10.X hash support [util.smartptr.hash]
+Paragraph 9 reads: 
 
    
-
-
    template <class T, class D> struct hash<unique_ptr<T,D>>;
-
    
-
 
    
-A partial specialization of the class template hash (20.7.17 [unord.hash]) shall be provided for instances of the
-unique_ptr template suitable for use as a key in unordered
-associative containers (23.5 [unord]) if and only if there is a
-hash specialization available for the type D::pointer.
-For an object p of type unqiue_ptr<T,D> the
-hash shall evaluate to the same value as hash<typename
-D::pointer>{}(p.get()).
+Throws: the stored exception, if an exception was stored and not 
+retrieved before.
 
    
+
    
+The "not retrieved before" suggests that only one exception is thrown, 
+but one exception for each call to get() is needed, and multiple calls 
+to get() even on the same shared_future object seem to be allowed. 
+
    
+
    
+I suggest removing "and not retrieved before" from the Throws paragraph. 
+I recommend adding a note that explains that multiple calls on get() are 
+allowed, and each call would result in an exception if an exception was 
+stored. 
+
    
 
-
    template <class T> struct hash<shared_ptr<T>>;
-
    
+
    [
+Batavia (2009-05):
+]
    
 
 
    
-A partial specialization of the class template hash (20.7.17 [unord.hash])
-shall be provided for instances of the shared_ptr template
-suitable for use as a key in unordered associative containers
-(23.5 [unord]). For an object p of type shared_ptr<T>
-the hash shall evaluate
-to the same value as hash<T*>{}(p.get()).
+
    
+We note there is a pending paper by Detlef
+on such future-related issues;
+we would like to wait for his paper before proceeding.
+
    
+
    
+Alisdair suggests we may want language to clarify that this
+get() function can be called from several threads
+with no need for explicit locking.
+
    
+
    
+Move to Open.
+
    
+
    
+
+
+
    Proposed resolution:
    
+
    
+Change 30.6.7 [future.shared_future]:
+
    
+
+
    const R& shared_future::get() const; 
+R& shared_future<R&>::get() const; 
+void shared_future<void>::get() const;
+
    
+
    
+
    ...
    
+
    
+-9- Throws: the stored exception, if an exception was stored and not retrieved before.
+
+[Note: Multiple calls on get() are 
+allowed, and each call would result in an exception if an exception was 
+stored. — end note]
+
+
    
 
    
 
    
 
@@ -21601,34 +18002,69 @@ to the same value as hash<T*>{}(p.get()).
 
 
 
+
 
    
-
    983. unique_ptr reference deleters should not be moved from
    
-
    Section: 20.8.9.2 [unique.ptr.single] Status: Review
- Submitter: Howard Hinnant Opened: 2009-02-10  Last modified: 2009-05-23
    
-
    View other active issues in [unique.ptr.single].
    
-
    View all other issues in [unique.ptr.single].
    
-
    View all issues with Review status.
    
+
    1108. thread.req.exception overly constrains implementations
    
+
    Section: 30.2.2 [thread.req.exception] Status: Tentatively Ready
+ Submitter: Christopher Kohlhoff Opened: 2009-04-25  Last modified: 2009-10-26
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
    
-Dave brought to my attention that when a unique_ptr has a non-const reference
-type deleter, move constructing from it, even when the unique_ptr containing
-the reference is an rvalue, could have surprising results:
+The current formulation of 30.2.2 [thread.req.exception]/2 reads:
 
    
-
-
    D d(some-state);
-unique_ptr<A, D&> p(new A, d);
-unique_ptr<A, D> p2 = std::move(p);
-// has d's state changed here?
-
    
-
+
    
+The error_category of the error_code reported by such an
+exception's code() member function is as specified in the error
+condition Clause.
+
    
 
    
-I agree with him.  It is the unique_ptr that is the rvalue, not the
-deleter.  When the deleter is a reference type, the unique_ptr should
-respect the "lvalueness" of the deleter.
+This constraint on the code's associated error_categor means an
+implementation must perform a mapping from the system-generated
+error to a generic_category() error code. The problems with this
+include:
 
    
 
+
      
+
    • 
+The mapping is always performed, even if the resultant value is
+ never used.
+
      • 
+
    • 
 
      
-Thanks Dave.
+The original error produced by the operating system is lost.
+
      
+
      • 
+
    
+
    
+The latter was one of Peter Dimov's main objections (in a private
+email discussion) to the original error_code-only design, and led to
+the creation of error_condition in the first place. Specifically,
+error_code and error_condition are intended to perform the following
+roles:
+
    
+
      
+
    • 
+error_code holds the original error produced by the operating
+ system.
+
      • 
+
    • 
+error_condition and the generic category provide a set of well
+ known error constants that error codes may be tested against.
+
      • 
+
    
+
    
+Any mapping determining correspondence of the returned error code to
+the conditions listed in the error condition clause falls under the
+"latitude" granted to implementors in 19.5.1.5 [syserr.errcat.objects].
+(Although obviously their latitude is restricted a little by the
+need to match the right error condition when returning an error code
+from a library function.)
+
    
+
    
+It is important that this error_code/error_condition usage is done
+correctly for the thread library since it is likely to set the
+pattern for future TR libraries that interact with the operating
+system.
 
    
 
 
    [
@@ -21636,396 +18072,246 @@ Batavia (2009-05):
 ]
    
 
 
    
-Seems correct, but complicated enough that we recommend moving to Review.
+Move to Open, and recommend the issue be deferred until after the next
+Committee Draft is issued.
+
    
+
+
    [
+2009-10 post-Santa Cruz:
+]
    
+
+
+
    
+Move to Tentatively Ready.
 
    
 
 
+
 
    Proposed resolution:
    
 
    
-Change 20.8.9.2.1 [unique.ptr.single.ctor], p20-21
+Change 30.2.2 [thread.req.exception]/2:
 
    
 
 
    
-
    template <class U, class E> unique_ptr(unique_ptr<U, E>&& u);
-
    
-
-
    
-
 
    
--20- Requires: If D E is not a reference type,
-construction of the deleter D from an rvalue of type E
-shall be well formed and shall not throw an exception.
+-2- The error_category (19.5.1.1) of the error_code reported by
+such an exception's code() member function 
+is as specified in the error condition Clause.
 
-Otherwise E is a reference type and construction of the deleter
-D from an lvalue of type E shall be well formed and
-shall not throw an exception.
+The error_code reported by such an exception's code() member
+function shall compare equal to one of the conditions specified in
+the function's error condition Clause. [Example: When the thread
+constructor fails:
 
-If D is
-a reference type, then E shall be the same type as D
-(diagnostic required). unique_ptr<U, E>::pointer shall be
-implicitly convertible to pointer. [Note: These
-requirements imply that T and U are complete types.
--- end note]
 
    
+
    
+ec.category() == implementation-defined // probably system_category
+ec == errc::resource_unavailable_try_again // holds true
+
    
 
-
    
--21- Effects: Constructs a unique_ptr which owns the
-pointer which u owns (if any). If the deleter
-E is not a reference type, it this
-deleter is move constructed from u's deleter, otherwise
-the reference this deleter is copy constructed
-from u.'s deleter. After the construction, u no longer
-owns a pointer. [Note: The deleter constructor can be implemented
-with std::forward<DE>. -- end
-note]
-
    
+
    
+— end example]
+
    
 
 
    
-
    
 
+
+
+
+
+
+
    
+
    1110. Is for_each overconstrained?
    
+
    Section: 25.2.4 [alg.foreach] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-04-29  Last modified: 2009-10-27
    
+
    View all other issues in [alg.foreach].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-Change 20.8.9.2.3 [unique.ptr.single.asgn], p1-3
+Quoting working paper for reference (25.2.4 [alg.foreach]):
 
    
 
 
    
-
    unique_ptr& operator=(unique_ptr&& u);
+
    template<InputIterator Iter, Callable<auto, Iter::reference> Function>
+  requires CopyConstructible<Function>
+  Function for_each(Iter first, Iter last, Function f);
 
    
 
    
-
 
    
--1- Requires: If the deleter D is not a reference type,
-Aassignment of the deleter D from an rvalue D shall not throw an exception.
-
-Otherwise the deleter D is a reference type,
-and assignment of the deleter D from an lvalue D shall not throw an exception.
+1 Effects: Applies f to the result of dereferencing every iterator in the
+ range [first,last), starting from first and proceeding to last - 1.
 
    
-
 
    
--2- Effects: reset(u.release()) followed by
-an move assignment from u's deleter to this deleter
-std::forward<D>(u.get_deleter()).
+2 Returns: f.
 
    
-
 
    
--3- Postconditions: This unique_ptr now owns the pointer
-which u owned, and u no longer owns it. [Note: If
-D is a reference type, then the referenced lvalue deleters are
-move assigned. -- end note]
+3 Complexity: Applies f exactly last - first times.
 
    
 
    
 
    
 
 
    
-Change 20.8.9.2.3 [unique.ptr.single.asgn], p6-7
+P2 implies the passed object f should be invoked at each stage, rather than
+some copy of f.  This is important if the return value is to usefully
+accumulate changes.  So the requirements are an object of type Function can
+be passed-by-value, invoked multiple times, and then return by value.  In
+this case, MoveConstructible is sufficient. This would open support for
+move-only functors, which might become important in concurrent code as you
+can assume there are no other references (copies) of a move-only type and so
+freely use them concurrently without additional locks.
 
    
 
-
    
-
    template <class U, class E> unique_ptr& operator=(unique_ptr<U, E>&& u);
-
    
-
    
+
    [
+See further discussion starting with c++std-lib-23686.
+]
    
+
+
+
    [
+Batavia (2009-05):
+]
    
 
+
    
 
    
-Requires: If the deleter E is not a reference type,
-Aassignment of the deleter D from an rvalue
-DE shall not throw an exception.
-
-Otherwise the deleter E is a reference type,
-and assignment of the deleter D from an lvalue E shall not throw an exception.
-unique_ptr<U, E>::pointer shall be implicitly convertible to pointer.
-[Note: These requirements imply that T and U>
-are complete types. -- end note]
+Pete suggests we may want to look at this in a broader context
+involving other algorithms.
+We should also consider the implications of parallelism.
 
    
-
 
    
-Effects: reset(u.release()) followed by
-an move assignment from u's deleter to this deleter
-std::forward<E>(u.get_deleter()).
-If either
-D or E is a reference type, then the referenced lvalue
-deleter participates in the move assignment.
+Move to Open, and recommend the issue be deferred until after the next
+Committee Draft is issued.
 
    
-
-
    
 
    
 
+
    [
+2009-10-14 Daniel de-conceptified the proposed resolution.
+]
    
 
 
+
    
+
    
+The note in 25.1 [algorithms.general]/9 already says the right thing:
+
    
+
    
+Unless otherwise specified, algorithms that take function objects
+as arguments are permitted to copy those function objects freely.
+
    
+
    
+So we only need to ensure that the wording for for_each is sufficiently
+clear, which is the intend of the following rewording.
+
    
+
    
 
+
    [
+2009-10-15 Daniel proposes:
+]
    
 
 
-
    
-
    985. Allowing throwing move
    
-
    Section: 23.2.1 [container.requirements.general] Status: Open
- Submitter: Rani Sharoni Opened: 2009-02-12  Last modified: 2009-05-23
    
-
    View other active issues in [container.requirements.general].
    
-
    View all other issues in [container.requirements.general].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    
+
      
+
    • 
 
      
-Introduction
-
      
-
-
      This proposal is meant to resolve potential regression of the
-N2800
-draft, see
-next section, and to relax the requirements for containers of types with
-throwing move constructors.
      
-
-
      The basic problem is that some containers operations, like push_back,
-have a strong exception safety
-guarantee (i.e. no side effects upon exception) that are not achievable when
-throwing move constructors are used since there is no way to guarantee revert
-after partial move. For such operations the implementation can at most provide
-the basic guarantee (i.e. valid but unpredictable) as it does with multi
-copying operations (e.g. range insert).
      
-
-
      For example, vector<T>::push_back() (where T has a move
-constructor) might resize the vector and move the objects to the new underlying
-buffer. If move constructor throws it might
-not be possible to recover the throwing object or to move the old objects back to
-the original buffer.
      
-
-
      The current draft is explicit by disallowing throwing move
-for some operations (e.g. vector<>::reserve) and not clear about other
-operations mentioned in 23.2.1 [container.requirements.general]/10
-(e.g. single element insert): it guarantees strong exception
-safety without explicitly disallowing a throwing move constructor.
+Add a new Requires clause just after the prototype declaration (25.2.4 [alg.foreach]):
 
      
-
+
      
 
      
-Regression
+Requires: Function shall be MoveConstructible
+( [moveconstructible]), CopyConstructible is not required.
 
      
-
-
      This section only refers to cases in which the contained object
-is by itself a standard container.
      
-
-
      Move constructors of standard containers are allowed to throw and therefore
-existing operations are broken, compared with C++03, due to move optimization.
-(In fact existing implementations like Dinkumware are actually throwing).
      
-
-
      For example, vector< list<int> >::reserve yields
-undefined behavior since list<int>'s move constructor is allowed to throw.
-On the other hand, the same operation has strong exception safety guarantee in
-C++03.
      
-
-
      There are few options to solve this regression:
      
-
-
        
-
      1. 
-Disallow throwing move and throwing default constructor
-
        2. 
-
-
      2. 
-Disallow throwing move but disallowing usage after move
-
        3. 
-
-
      3. 
-Special casing
+
      
 
      • 
-
 
    • 
-Disallow throwing move and making it optional
-
      • 
-
-
-
-
      Option 1 is suggested by proposal
-N2815
-but it might not be applicable for existing implementations for which
-containers default constructors are throwing.
      
-
-
      Option 2 limits the usage significantly and it's error prone
-by allowing zombie objects that are nothing but destructible (e.g. no clear()
-is allowed after move). It also potentially complicates the implementation by
-introducing special state.
      
-
-
      Option 3 is possible, for example, using default
-construction and swap instead of move for standard containers case. The
-implementation is also free to provide special hidden operation for non
-throwing move without forcing the user the cope with the limitation of option-2
-when using the public move.
      
-
-
      Option 4 impact the efficiency in all use cases due to rare throwing move.
      
-
-
      The proposed wording will imply option 1 or 3 though option 2 is also
-achievable using more wording. I personally oppose to option 2 that has impact
-on usability.
      
-
 
      
-Relaxation for user types
+Change 25.2.4 [alg.foreach]/2 as indicated:
 
      
 
-
      Disallowing throwing move constructors in general seems very restrictive
-since, for example, common implementation of move will be default construction
-+ swap so move will throw if the
-default constructor will throw. This is currently the case with the Dinkumware
-implementation of node based containers (e.g. std::list)
-though this section doesn't refer to standard types.
      
-
-
      For throwing move constructors it seem that the implementation should have
-no problems to provide the basic guarantee instead of the strong one. It's
-better to allow throwing move constructors with basic guarantee than to
-disallow it silently (compile and run), via undefined behavior.
      
-
-
      There might still be cases in which the relaxation will break existing generic
-code that assumes the strong guarantee but it's broken either way given a
-throwing move constructor since this is not a preserving optimization. 
      
+
      
+Returns: std::move(f).
+
      
+
+
    
+
    
 
 
    [
-Batavia (2009-05):
+2009-10 post-Santa Cruz:
 ]
    
 
+
 
    
-
    
-Bjarne comments (referring to his draft paper):
-"I believe that my suggestion simply solves that.
-Thus, we don't need a throwing move."
-
    
-
    
-Move to Open and recommend it be deferred until after the next
-Committee Draft is issued.
-
    
+Move to Tentatively Ready, using Daniel's wording without the portion
+saying "CopyConstructible is not required".
 
    
 
+
    [
+2009-10-27 Daniel adds:
+]
    
 
-
    Proposed resolution:
    
-
-
    
-23.2.1 [container.requirements.general]  paragraph 10 add footnote:
-
    
 
 
    
 
    
--10- Unless otherwise specified (see 23.1.4.1, 23.1.5.1, 23.2.2.3, and
-23.2.6.4) all container types defined in this Clause meet the following
-additional requirements:
-
    
-
      
-
    • ...
      • 
-
    
-
-
    
-[Note: for compatibility with C++
-2003, when "no effect" is required, standard containers should not use the
-value_type's throwing move constructor when the contained object is by itself a
-standard container. -- end note]
+I see that during the Santa Cruz meeting the originally proposed addition
 
    
 
-
    
-
-
    23.2.5.1 [unord.req.except] change paragraph 2 to say: 
    
-
 
    
-
    
--2- For unordered associative containers, if an exception is
-thrown by any operation other than the container's hash function from within an
-insert() function inserting a single element, the insert()
-function has no effect unless the exception is thrown by the contained
-object move constructor.
-
    
-
-
    
--4- For unordered associative containers, if an exception is
-thrown from within a rehash() function other than by the container's hash
-function or comparison function, the rehash() function has no effect
-unless the exception is thrown by the contained
-object move constructor.
    
-
+, CopyConstructible is not required.
 
    
 
 
    
-23.3.2.3 [deque.modifiers] change paragraph 2 to say:
+was removed. I don't think that this removal was a good idea. The combination
+of 25.1 [algorithms.general]/9
 
    
 
 
    
--2- Remarks: If an exception is thrown other than by
-the copy constructor, move constructor
-or assignment operator of T
-there are no effects.
-If an exception is thrown by push_back() or emplace_back()
-function, that function has no effects unless the exception is thrown by
-the move constructor of T.
+[Note: Unless otherwise specified, algorithms that take function objects
+as arguments are permitted to copy those function objects freely.[..]
 
    
 
 
    
-23.3.2.3 [deque.modifiers] change paragraph 6 to say:
+with the fact that CopyConstructible is a refinement MoveConstructible
+makes it necessary that such an explicit statement is given. Even the
+existence of the usage of std::move in the Returns clause doesn't
+help much, because this would still be well-formed for a CopyConstructible
+without move constructor. Let me add that the originally proposed
+addition reflects current practice in the standard, e.g. 25.3.9 [alg.unique]/5
+usages a similar terminology.
 
    
 
-
    
--6- Throws: Nothing unless an exception is thrown by the copy
-constructor, move constructor or assignment operator of T.
-
    
-
 
    
-23.3.6.2 [vector.capacity] remove paragraph 2
+For similar wording need in case for auto_ptr see 973.
 
    
 
-
    
--2- Requires: If value_type has a move constructor,
-that constructor shall not throw any exceptions.
+
    [
+Howard: Moved from Tentatively Ready to Open.
+]
    
+
 
    
 
-
    
-23.3.6.2 [vector.capacity] paragraph 3 change to say:
-
    
 
-
    
--3- Effects: A directive that informs a vector
-of a planned change in size, so
-that it can manage the storage allocation accordingly. After reserve(),
-capacity() is greater or equal to the argument of reserve
-if reallocation happens; and equal
-to the previous value of capacity()
-otherwise. Reallocation happens at this point if and only if the current
-capacity is less than the argument of reserve().
-If an exception is thrown, there are no effects
-unless the exception is thrown by the contained object move constructor.
-
    
 
+
    Proposed resolution:
    
+
      
+
    • 
 
      
-23.3.6.2 [vector.capacity] paragraph 12 change to say:
+Add a new Requires clause just after the prototype declaration (25.2.4 [alg.foreach]):
 
      
-
 
      
--12- Requires: If value_type has a move constructor,
-that constructor shall not throw any exceptions.
-If an exception is thrown, there are no effects unless the exception is thrown by
-the contained object move constructor.
-
      
-
 
      
-23.3.6.4 [vector.modifiers] change paragraph 1 to say:
+Requires: Function shall be MoveConstructible
+( [moveconstructible]).
 
      
-
-
      
--1- Requires: If value_type has a move constructor,
-that constructor shall not throw any exceptions.
-Remarks: If an exception is thrown by push_back()
-or emplace_back() function, that function has no effect unless the
-exception is thrown by the move constructor of T.
 
      
-
+
      • 
+
    • 
 
      
-23.3.6.4 [vector.modifiers] change paragraph 2 to say:
+Change 25.2.4 [alg.foreach]/2 as indicated:
 
      
 
 
      
--2- Remarks: Causes reallocation if the new size is greater than
-the old capacity. If no reallocation happens, all the iterators and
-references before the insertion point remain valid. If an exception is
-thrown other than by the copy constructor, move constructor
-or assignment operator of T or by any InputIterator
-operation there are no effects.
+Returns: std::move(f).
 
      
+
      • 
+
    
 
-
    
-23.3.6.4 [vector.modifiers] change paragraph 6 to say:
-
    
 
-
    
--6- Throws: Nothing unless an exception is thrown by the copy
-constructor, move constructor or assignment operator of T.
-
    
 
 
 
@@ -22033,258 +18319,185 @@ constructor, move constructor or assignment operator of T.
 
 
 
    
-
    987. reference_wrapper and function types
    
-
    Section: 20.7.5 [refwrap] Status: Open
- Submitter: Howard Hinnant Opened: 2009-02-18  Last modified: 2009-07-14
    
-
    View all other issues in [refwrap].
    
-
    View all issues with Open status.
    
+
    1112. bitsets and new style for loop
    
+
    Section: 20.3.7 [template.bitset] Status: Tentatively NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-05-06  Last modified: 2009-10-26
    
+
    View other active issues in [template.bitset].
    
+
    View all other issues in [template.bitset].
    
+
    View all issues with Tentatively NAD Future status.
    
 
    Discussion:
    
 
    
-The synopsis in 20.7.5 [refwrap] says:
+Std::bitset is a homogeneous container-like sequence of bits, yet it does
+not model the Range concept so cannot be used with the new for-loop syntax.
+It is the only such type in the library that does NOT support the new for
+loop.
 
    
-
-
    template <ObjectType T> class reference_wrapper
-...
-
    
-
 
    
-And then paragraph 3 says:
+The obvious reason is that bitset does not support iterators.
 
    
-
-
    
 
    
-The template instantiation reference_wrapper<T> shall be
-derived from std::unary_function<T1, R> only if the type
-T is any of the following:
+At least two reasonable solutions are available:
 
    
-
-
      
+
        
 
      1. 
-a function type or a pointer to function type taking one argument of
-type T1 and returning R
+Add an iterator interface to bitset, bringing its interface close to that
+of std::array
 
        2. 
-
    
-
    
-
+
  • 
+Provide an unspecified concept_map for Range<bitset>.
+
    • 
+
 
    
-But function types are not ObjectTypes.
+The latter will still need some kind of iterator-like adapter for bitset,
+but gives implementers greater freedom on the details. E.g. begin/end return
+some type that simply invokes operator[] on the object it wraps, and
+increments its index on operator++.  A vendor can settle for InputIterator
+support, rather than wrapping up a full RandomAccessIterator.
 
    
-
 
    
-Paragraph 4 contains the same contradiction.
+I have a mild preference for option (ii) as I think it is less work to
+specify at this stage of the process, although (i) is probably more useful
+in the long run.
 
    
-
-
    [
-Post Summit:
-]
    
-
-
-
    
 
    
-Jens: restricted reference to ObjectType
+Hmm, my wording looks a little woolly, as it does not say what the element
+type of the range is.  Do I get a range of bool, bitset<N>::reference, or
+something else entirely?
 
    
 
    
-Recommend Review.
+I guess most users will assume the behaviour of reference, but expect to
+work with bool.  Bool is OK for read-only traversal, but you really need to
+take a reference to a bitset::reference if you want to write back.
 
    
-
    
 
 
    [
-Post Summit, Peter adds:
+Batavia (2009-05):
 ]
    
 
-
 
    
-
    
-In https://svn.boost.org/trac/boost/ticket/1846
-however Eric Niebler makes the very reasonable point that reference_wrapper<F>,
-where F is a function type, represents a reference to a function,
-a legitimate entity. So boost::ref was changed to allow it.
-
    
-
    
-https://svn.boost.org/trac/boost/browser/trunk/libs/bind/test/ref_fn_test.cpp
-
    
-
    
-Therefore, I believe an alternative proposed resolution for issue 987 could simply
-allow reference_wrapper to be used with function types.
-
    
+Move to Open.
+We further recommend this be deferred until after the next Committee Draft.
 
    
 
 
    [
-Post Summit, Howard adds:
+2009-05-25 Alisdair adds:
 ]
    
 
 
 
    
 
    
-I agree with Peter (and Eric).  I got this one wrong on my first try.  Here
-is code that demonstrates how easy (and useful) it is to instantiate
-reference_wrapper with a function type:
-
    
-
-
    #include <functional>
-
-template <class F>
-void test(F f);
-
-void f() {}
-
-int main()
-{
-    test(std::ref(f));
-}
-
    
-
-
    
-Output (link time error shows type of reference_wrapper instantiated
-with function type):
-
    
-
-
    Undefined symbols:
-  "void test<std::reference_wrapper<void ()()> >(std::reference_wrapper<void ()()>)",...
-
    
-
-
    
-I've taken the liberty of changing the proposed wording to allow function types
-and set to Open.  I'll also freely admit that I'm not positive ReferentType
-is the correct concept.
+I just stumbled over the Range concept_map for valarray and this should
+probably set the precedent on how to write the wording.
 
    
 
-
    
-
-
-
 
    [
-Batavia (2009-05):
+Howard: I've replaced the proposed wording with Alisdair's suggestion.
 ]
    
 
-
    
-
    
-Howard observed that FunctionType,
-a concept not (yet?) in the Working Paper,
-is likely the correct constraint to be applied.
-However, the proposed resolution provides an adequate approximation.
-
    
-
    
-Move to Review.
-
    
+
 
    
 
 
    [
-2009-05-23 Alisdair adds:
+2009-07-24 Daniel modifies the proposed wording for non-concepts.
 ]
    
 
 
-
    
-
    
-By constraining to PointeeType we rule out the ability for T to be a
-reference, and call in reference-collapsing.  I'm not sure if this is
-correct and intended, but would like to be sure the case was considered.
-
    
-
    
-Is dis-allowing reference types and the
-implied reference collapsing the intended result?
-
    
-
    
-
 
    [
-2009-07 Frankfurt
+2009-10 post-Santa Cruz:
 ]
    
 
 
 
    
-Moved from Review to Open only because the wording needs to be
-tweaked for concepts removal.
+Mark as Tentatively NAD Future due to the loss of concepts.
 
    
 
 
 
 
    Proposed resolution:
    
+
      
+
    1. 
 
      
-Change the synopsis in 20.7 [function.objects]:
+Modify the section 20.3.7 [template.bitset] <bitset> synopsis by adding
+the following at the end of the synopsis:
 
      
-
-
      // 20.6.5, reference_wrapper:
-template <ObjectType ReferentType T>
-  requires PointeeType<T>
-  class reference_wrapper;
-
-template <ObjectType PointeeType T>
-  reference_wrapper<T> ref(T&);
-
-template <ObjectType PointeeType T>
-  reference_wrapper<const T> cref(const T&);
-
-template <ObjectType PointeeType T>
-  reference_wrapper<T> ref(reference_wrapper<T>);
-template <ObjectType PointeeType T>
-  reference_wrapper<const T> cref(reference_wrapper<T>);
+
      
+// XX.X.X bitset range access [bitset.range]
+template<size_t N> unspecified-1 begin(bitset<N>&);
+template<size_t N> unspecified-2 begin(const bitset<N>&);
+template<size_t N> unspecified-1 end(bitset<N>&);
+template<size_t N> unspecified-2 end(const bitset<N>&);
+
 
      
-
+
      2. 
+
    2. 
 
      
-Change the synopsis in 20.7.5 [refwrap]:
+Add a new section "bitset range access" [bitset.range]
+after the current section 20.3.7.3 [bitset.operators] with the following series of
+paragraphs:
 
      
-
-
      template <ObjectType ReferentType T>
-  requires PointeeType<T>
-  class reference_wrapper
-   ...
-
      
-
+
      
 
      
-Change the prototypes in 20.7.5.5 [refwrap.helpers]:
+
+1.  In the begin and end function templates that follow, unspecified-1
+is a type that meets the requirements of a mutable random access
+iterator (24.2.5 [random.access.iterators]) whose value_type is bool and
+whose reference type is bitset<N>::reference.
+unspecified-2 is a type that meets the requirements of a constant
+random access iterator (24.2.5 [random.access.iterators]) whose value_type
+is bool and whose reference type is bool.
+
 
      
+
      
+template<size_t N> unspecified-1 begin(bitset<N>&);
+template<size_t N> unspecified-2 begin(const bitset<N>&);
+
+
      
+
      
+2.  Returns: an iterator referencing the first bit in the bitset.
+
      
+
+
      
+template<size_t N> unspecified-1 end(bitset<N>&);
+template<size_t N> unspecified-2 end(const bitset<N>&);
+
      
+
+
      
+3.  Returns: an iterator referencing one past the last bit in the
+bitset.
+
      
+
      
+
      3. 
+
    
+
+
+
 
-
    template <ObjectType PointeeType T>
-  reference_wrapper<T> ref(T&);
-...
-template <ObjectType PointeeType T>
-  reference_wrapper<const T> cref(const T&);
-...
-template <ObjectType PointeeType T>
-  reference_wrapper<T> ref(reference_wrapper<T>);
-...
-template <ObjectType PointeeType T>
-  reference_wrapper<const T> cref(reference_wrapper<T>);
-
    
 
 
 
-
    Rationale:
    
-
    
-a) The occurrence of T& in the function signature auto-implies
-std::ReferentType,
-this is due to 14.11.1.2 [temp.req.impl]/4 bullet 4
-
    
-
    
-b) The occurrence of the constrained template reference_wrapper<T> in
-the remaining
-signatures lets kick in 14.11.1.2 [temp.req.impl]/4 bullet 1 and adds *all* requirements of
-this template. But we need to add at least *one* requirement (and it
-was an arbitrary,
-but natural decision to require std::PointeeType here) to *activate*
-this. If we hadn't done
-this, we were in unconstrained mode!
-
    
 
 
 
 
 
 
    
-
    996. Move operation not well specified
    
-
    Section: 17 [library] Status: Open
- Submitter: David Abrahams Opened: 2009-03-06  Last modified: 2009-05-23
    
-
    View other active issues in [library].
    
-
    View all other issues in [library].
    
-
    View all issues with Open status.
    
+
    1113. bitset::to_string could be simplified
    
+
    Section: 20.3.7 [template.bitset] Status: Tentatively Ready
+ Submitter: Alisdair Meredith Opened: 2009-05-09  Last modified: 2009-10-26
    
+
    View other active issues in [template.bitset].
    
+
    View all other issues in [template.bitset].
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
    
-There are lots of places in the standard where we talk about "the move
-constructor" but where we mean "the move operation," i.e.  T( move( x ) ).
+In 853 our resolution is changing the signature by adding two
+defaulting arguments to 3 calls.  In principle, this means that ABI breakage
+is not an issue, while API is preserved.
 
    
 
    
-We also don't account for whether that operation modifies x or not, and
-we need to.
+With that observation, it would be very nice to use the new ability to
+supply default template parameters to function templates to collapse all 3
+signatures into 1.  In that spirit, this issue offers an alternative resolution
+than that of 853.
 
    
 
 
    [
@@ -22292,142 +18505,195 @@ Batavia (2009-05):
 ]
    
 
 
    
-Move to Open, pending proposed wording from Dave for further
-review.
+Move to Open,
+and look at the issue again after 853 has been accepted.
+We further recommend this be deferred until after the next Committee Draft.
 
    
 
+
    [
+2009-10 post-Santa Cruz:
+]
    
 
-
    Proposed resolution:
    
-
    
-
    
 
+
    
+Move to Tentatively Ready.
+
    
 
 
 
+
    Proposed resolution:
    
 
-
    
-
    999. Taking the address of a function
    
-
    Section: 20.8.8.1 [object.addressof] Status: Open
- Submitter: Peter Dimov Opened: 2009-03-09  Last modified: 2009-07-14
    
-
    View all other issues in [object.addressof].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
      
+
    1. 
 
      
-The same fix (reference 987) may be applied to addressof, which is also constrained to
-ObjectType. (That was why boost::ref didn't work with functions - it
-tried to apply boost::addressof and the reinterpret_cast<char&>
-implementation of addressof failed.)
+In 20.3.7 [template.bitset]/1 (class bitset) ammend:
 
      
-
-
-
-
      [
-Batavia (2009-05):
-]
      
-
-
      
-
      
-We agree.
-
      
-
      
-Move to Tentatively Ready.
-
      
-
      
-
-
      [
-2009-07 Frankfurt
-]
      
-
-
-
      
-Moved from Tentatively Ready to Open only because the wording needs to be
-tweaked for concepts removal.
-
      
-
-
-
-
      Proposed resolution:
      
-
      
-Change the synopsis in 20.8 [memory]:
-
      
-
-
      template <ObjectType PointeeType T>
-  T* addressof(T& r);
+
      template <class charT = char,
+            class traits = char_traits<charT>,
+            class Allocator = allocator<charT>> 
+  basic_string<charT, traits, Allocator>
+  to_string(charT zero = charT('0'), charT one = charT('1')) const;
+template <class charT, class traits> 
+  basic_string<charT, traits, allocator<charT> > to_string() const; 
+template <class charT> 
+  basic_string<charT, char_traits<charT>, allocator<charT> > to_string() const; 
+basic_string<char, char_traits<char>, allocator<char> > to_string() const;
 
      
-
+
      2. 
+
    2. 
 
      
-Change 20.8.8.1 [object.addressof]:
+In 20.3.7.2 [bitset.members] prior to p35 ammend:
 
      
-
-
      template <ObjectType PointeeType T>
-  T* addressof(T& r);
+
      template <class charT = char,
+            class traits = char_traits<charT>,
+            class Allocator = allocator<charT>> 
+  basic_string<charT, traits, Allocator>
+  to_string(charT zero = charT('0'), charT one = charT('1')) const;
 
      
+
      3. 
+
    3. 
+Strike 20.3.7.2 [bitset.members] paragraphs 37 -> 39 (including signature
+above 37)
+
      4. 
+
    
 
 
-
    Rationale:
    
-
    
-a) The occurrence of T& in the function signature auto-implies
-std::ReferentType,
-this is due to 14.11.1.2 [temp.req.impl]/4 bullet 4
-
    
-
 
 
 
 
 
    
-
    1004. Response to UK 179
    
-
    Section: 17.6.3.8 [res.on.functions] Status: Ready
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
    
-
    View all other issues in [res.on.functions].
    
-
    View all issues with Ready status.
    
+
    1114. Type traits underspecified
    
+
    Section: 20.6 [meta] Status: Tentatively Ready
+ Submitter: Daniel Krügler Opened: 2009-05-12  Last modified: 2009-10-26
    
+
    View all other issues in [meta].
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
-
    Addresses UK 179
    
+
    
+Related to 975 and 1023.
+
    
 
 
    
-According to the 4th bullet there is a problem if "if any replacement
-function or handler function or destructor operation throws an
-exception". There should be no problem throwing exceptions so long as
-they are caught within the function.
+The current wording in 20.6.1 [meta.rqmts] is still unclear concerning
+it's requirements on the type traits classes regarding ambiguities.
+Specifically it's unclear
 
    
 
+
      
+
    • 
+if a predicate trait (20.6.4 [meta.unary], 20.6.5 [meta.rel]) could derive from both
+true_type/false_type.
+
      • 
+
    • 
+if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could ambiguously derive
+from the same specified result type.
+
      • 
+
    • 
+if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could derive from other
+integral_constant types making the contained names ambiguous
+
      • 
+
    • 
+if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could have other base
+classes that contain members hiding the name of the result type members
+or make the contained member names ambiguous.
+
      • 
+
    
+
 
    [
 Batavia (2009-05):
 ]
    
 
 
    
-The phrasing "throws an exception" is commonly used elsewhere
-to mean "throws or propagates an exception."
-Move to Open pending a possible more general resolution.
+
    
+Alisdair would prefer to factor some of the repeated text,
+but modulo a corner case or two,
+he believes the proposed wording is otherwise substantially correct.
+
    
+
    
+Move to Open.
+
    
 
    
 
 
    [
-2009-07 Frankfurt:
+2009-10 post-Santa Cruz:
 ]
    
 
 
 
    
-Replace "propagates" in the proposed resolution with the phrase "exits
-via" and move to Ready.
+Move to Tentatively Ready.
 
    
 
 
 
 
    Proposed resolution:
    
+
    [
+The usage of the notion of a BaseCharacteristic below
+might be
+useful in other places - e.g. to define the base class relation in
+20.7.5 [refwrap], 20.7.14 [func.memfn], or 20.7.15.2 [func.wrap.func].
+In this case it's definition should probably
+be moved to Clause 17
+]
    
+
+
+
      
+
    1. 
 
      
-Change the 4th bullet of 17.6.3.8 [res.on.functions], p2:
+Change 20.6.1 [meta.rqmts]/1 as indicated:
 
      
-
 
      
-
        
+[..] It shall be DefaultConstructible, CopyConstructible, and publicly
+and unambiguously derived, directly or indirectly, from
+its BaseCharacteristic, which is a specialization of the
+template integral_constant (20.6.3), with the arguments to the template
+integral_constant determined by the requirements for the particular
+property being described. The member names of the
+BaseCharacteristic shall be unhidden and unambiguously
+available in the UnaryTypeTrait.
+
      
+
      2. 
+
    2. 
+
      
+Change 20.6.1 [meta.rqmts]/2 as indicated:
+
      
+
      
+[..] It shall be DefaultConstructible, CopyConstructible, and publicly
+and unambiguously derived, directly or indirectly, from
+an instance its BaseCharacteristic, which is a
+specialization of the template integral_constant (20.6.3), with
+the arguments to the template integral_constant determined by the
+requirements for the particular relationship being described. The
+member names of the BaseCharacteristic shall be unhidden
+and unambiguously available in the BinaryTypeTrait.
+
      
+
      3. 
 
    3. 
-if any replacement function or handler function or destructor operation
-throws exits via an exception, unless specifically
-allowed in the applicable Required behavior: paragraph.
+
      
+Change 20.6.4 [meta.unary]/2 as indicated:
+
      
+
      
+Each of these templates shall be a UnaryTypeTrait (20.6.1),
+publicly derived directly or indirectly from true_type if the
+corresponding condition is true, otherwise from false_type
+where its BaseCharacteristic shall be true_type if the
+corresponding condition is true, otherwise false_type.
+
      
 
      4. 
-
+
    4. 
+
      
+Change 20.6.5 [meta.rel]/2 as indicated:
+
      
+
+
      
+Each of these templates shall be a BinaryTypeTrait (20.6.1),
+publicly derived directly or indirectly from true_type if the
+corresponding condition is true, otherwise from false_type
+where its BaseCharacteristic shall be true_type if the
+corresponding condition is true, otherwise false_type.
 
      
+
      5. 
+
    
 
 
 
@@ -22435,902 +18701,835 @@ allowed in the applicable Required behavior: paragraph.
 
 
 
    
-
    1008. nested_exception wording unclear
    
-
    Section: 18.8.6 [except.nested] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-04
    
-
    View other active issues in [except.nested].
    
-
    View all other issues in [except.nested].
    
-
    View all issues with Open status.
    
+
    1115. va_copy missing from Standard macros table
    
+
    Section: C.2 [diff.library] Status: Tentatively NAD Editorial
+ Submitter: Miles Zhao Opened: 2009-05-23  Last modified: 2009-10-26
    
+
    View all other issues in [diff.library].
    
+
    View all issues with Tentatively NAD Editorial status.
    
 
    Discussion:
    
-
-
    Addresses JP 31
    
-
 
    
-It is difficult to understand in which case nested_exception is applied.
+In "Table 122 -- Standard macros" of C.2 [diff.library], which lists the 56 macros
+inherited from C library, va_copy seems to be missing. But in
+"Table 21 -- Header <cstdarg> synopsis" (18.10 [support.runtime]), there is.
 
    
 
 
    [
-Summit:
+2009-10 post-Santa Cruz:
 ]
    
 
- 
+
 
    
-Alisdair will add an example in an update to
-N2619.
+Mark as Tentatively NAD Editorial, if Pete disagrees, Howard
+will move to Tentatively Ready
 
    
 
 
 
 
    Proposed resolution:
    
+
    
+Add va_copy to Table 122 -- Standard macros in C.2 [diff.library].
+
    
 
 
 
 
 
 
    
-
    1009. InputIterator post-increment dangerous
    
-
    Section: 24.2.1 [iterator.iterators] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-28
    
+
    1118. tuple query APIs do not support cv-qualification
    
+
    Section: 20.5.2.5 [tuple.helper] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-10-26
    
+
    View other active issues in [tuple.helper].
    
+
    View all other issues in [tuple.helper].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
-
-
    Addresses UK 251
    
-
 
    
-The post-increment operator is dangerous for a general InputIterator.
-The multi-pass guarantees that make it meaningful are defined as part of
-the ForwardIterator refinement. Any change will affect only constrained
-templates that have not yet been written, so should not break existing
-user iterators which remain free to add these operations. This change
-will also affect the generalised OutputIterator, although there is no
-percieved need for the post-increment operator in this case either.
+The APIs tuple_size and tuple_element do not support
+cv-qualified tuples, pairs or arrays.
+
    
+
    
+The most generic solution would be to supply partial specializations once
+for each cv-type in the tuple header.  However, requiring this header for
+cv-qualified pairs/arrays seems unhelpful.  The BSI editorial
+suggestion (UK-198/US-69,
+N2533)
+to merge tuple into <utility> would help with pair,
+but not array.  That might be resolved by making a dependency between the
+<array> header and <utility>, or simply recognising
+the dependency be fulfilled in a Remark.
 
    
 
 
    [
-2009-07-28 Alisdair adds:
+2009-05-24 Daniel adds:
 ]
    
 
 
 
    
-We still think the issue is relevant, but needs totally rewording in
-non-concept language.  We would like to see the issue retained as Open,
-rather than deferred as NAD Concepts.  Review status is no longer
-appropriate.
-
    
-
-
-
-
    Proposed resolution:
    
 
    
-Change 24.2.1 [iterator.iterators]:
+All tuple_size templates with a base class need to derive publicly, e.g.
 
    
 
-
    concept Iterator<typename X> : Semiregular<X> { 
-  MoveConstructible reference = typename X::reference; 
-  MoveConstructible postincrement_result;
-
-  requires HasDereference<postincrement_result>;
-
-  reference operator*(X&&); 
-  X& operator++(X&); 
-  postincrement_result operator++(X&, int);
-}
-
    
-
-
    ...
    
-
    postincrement_result operator++(X& r, int);
-
    
-
-
    
--3- Effects: equivalent to { X tmp = r; ++r; return tmp; }.
-
    
-
-
    
+
    template <IdentityOf T> class tuple_size< const T > :
+   public tuple_size<T> {};
+
    
 
 
    
-Change 24.2.2 [input.iterators]:
+The same applies to the tuple_element class hierarchies.
 
    
-
-
    
-
    concept InputIterator<typename X> : Iterator<X>, EqualityComparable<X> { 
-  ObjectType value_type = typename X::value_type; 
-  MoveConstructible pointer = typename X::pointer; 
-
-  SignedIntegralLike difference_type = typename X::difference_type; 
-
-  requires IntegralType<difference_type> 
-        && Convertible<reference, const value_type &>; 
-        && Convertible<pointer, const value_type*>; 
-
-  requires Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
-
-  pointer operator->(const X&); 
-}
-
    
-
    
-
 
    
-Change 24.2.3 [output.iterators]:
+What is actually meant with the comment
 
    
-
 
    
-
    auto concept OutputIterator<typename X, typename Value> { 
-  requires Iterator<X>; 
-
-  typename reference = Iterator<X>::reference; 
-  typename postincrement_result = Iterator<X>::postincrement_result;
-  requires SameType<reference, Iterator<X>::reference> 
-        && SameType<postincrement_result, Iterator<X>::postincrement_result>
-        && Convertible<postincrement_result, const X&>
-        && HasAssign<reference, Value> 
-        && HasAssign<HasDereference<postincrement_result>::result_type, Value>;
-}
-
    
+this solution relies on 'metafunction forwarding' to inherit the
+nested typename type
 
    
-
 
    
-Change 24.2.4 [forward.iterators]:
+?
+
    
+
    
+I ask, because all base classes are currently unconstrained and their
+instantiation is invalid in the constrained context of the tuple_element partial
+template specializations.
 
    
+
    
 
 
    [
-See 1084 which is attempting to change this same area in a compatible
-way.
+2009-05-24 Alisdair adds:
 ]
    
 
 
-
    
-
    concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> { 
-  requires Convertible<postincrement_result, const X&>;
-
-  MoveConstructible postincrement_result;
-  requires HasDereference<postincrement_result>
-        && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
-
-  postincrement_result operator++(X&, int);
-
-  axiom MultiPass(X a, X b) { 
-    if (a == b) *a == *b; 
-    if (a == b) ++a == ++b; 
-  } 
-}
-
    
-
-
    
-
    -4- ...
    
-
    
-
-
    postincrement_result operator++(X& r, int);
-
    
-
 
    
 
    
--5- Effects: equivalent to { X tmp = r; ++r; return tmp; }.
+I think a better solution might be to ask Pete editorially to change all
+declarations of tupling APIs to use the struct specifier instead of class.
 
    
-
    
-
-
    
-
-
-
-
-
-
-
    
-
    1011. next/prev wrong iterator type
    
-
    Section: 24.4 [iterator.operations] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-14
    
-
    View other active issues in [iterator.operations].
    
-
    View all other issues in [iterator.operations].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    Addresses UK 271
    
-
 
    
-next/prev return an incremented iterator without changing the value of
-the original iterator. However, even this may invalidate an
-InputIterator. A ForwardIterator is required to guarantee the
-'multipass' property.
+"metafunction forwarding" refers to the MPL metafunction protocol, where a
+metafunction result is declared as a nested typedef with the name "type",
+allowing metafunctions to be chained by means of inheritance.  It is a
+neater syntax than repeatedly declaring a typedef, and inheritance syntax is
+slightly nicer when it comes to additional typename keywords.
+
    
+
    
+The constrained template with an unconstrained base is a good observation
+though.
 
    
-
-
    [
-Batavia (2009-05):
-]
    
-
-
    
-We agree with the proposed resolution.
-Move to Tentatively Ready.
 
    
 
 
    [
-2009-07 Frankfurt
+2009-10 post-Santa Cruz:
 ]
    
 
 
 
    
-Moved from Tentatively Ready to Open only because the wording needs to be
-tweaked for concepts removal.
+Move to Open, Alisdair to provide wording. Once wording is
+provided, Howard will move to Review.
 
    
 
 
 
 
    Proposed resolution:
    
 
    
-Change  [iterator.synopsis]:
+Add to 20.5.1 [tuple.general] p2 (Header <tuple> synopsis)
 
    
 
-
    template <InputIterator ForwardIterator Iter> 
-  Iter next(Iter x, 
-    Iter::difference_type n = 1);
-
    
+
    // 20.5.2.3, tuple helper classes:
+template <IdentityOf T> class tuple_size; // undefined
+template <IdentityOf T> class tuple_size< const T > : tuple_size<T> {};
+template <IdentityOf T> class tuple_size< volatile T > : tuple_size<T> {};
+template <IdentityOf T> class tuple_size< const volatile T > : tuple_size<T> {};
 
-
    
-Change 24.4 [iterator.operations], p6:
-
    
+template <VariableType... Types> class tuple_size<tuple<Types...> >;
 
-
    template <InputIterator ForwardIterator Iter> 
-  Iter next(Iter x, 
-    Iter::difference_type n = 1);
+template <size_t I, IdentityOf T> class tuple_element; // undefined
+template <size_t I, IdentityOf T> class tuple_element<I, const T>;
+template <size_t I, IdentityOf T> class tuple_element<I, volatile T>;
+template <size_t I, IdentityOf T> class tuple_element<I, const volatile T>;
+
+template <size_t I, VariableType... Types>
+  requires True<(I < sizeof...(Types))> class tuple_element<I, tuple<Types...> >;
 
    
 
+
    
+Add to 20.5.2.5 [tuple.helper]
+
    
+
    [
+(note that this solution relies on 'metafunction forwarding' to inherit the
+nested typename type)
+]
    
 
 
+
    template <class... Types>
+class tuple_size<tuple<Types...> >
+  : public integral_constant<size_t, sizeof...(Types)> { };
 
+template <size_t I, class... Types>
+requires True<(I < sizeof...(Types))>
+class tuple_element<I, tuple<Types...> > {
+public:
+  typedef TI type;
+};
 
+template <size_t I, IdentityOf T>
+  class tuple_element<I, const T> : add_const<tuple_element<I,T>> {};
 
-
    
-
    1012. reverse_iterator default ctor should value initialize
    
-
    Section: 24.5.1.2.1 [reverse.iter.cons] Status: Tentatively Ready
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
    
-
    View all issues with Tentatively Ready status.
    
-
    Discussion:
    
+template <size_t I, IdentityOf T>
+  class tuple_element<I, volatile T> : add_volatile<tuple_element<I,T>> {};
 
-
    Addresses UK 277
    
+template <size_t I, IdentityOf T>
+  class tuple_element<I, const volatile T> : add_cv<tuple_element<I,T>> {};
+
    
 
-
    
-The default constructor default-initializes current, rather than
-value-initializes. This means that when Iterator corresponds to a
-trivial type, the current member is left un-initialized, even when the
-user explictly requests value intialization! At this point, it is not
-safe to perform any operations on the reverse_iterator other than assign
-it a new value or destroy it. Note that this does correspond to the
-basic definition of a singular iterator.
-
    
 
-
    [
-Summit:
-]
    
 
 
-
    
-Agree with option i.
-
    
 
+
    
+
    1119. tuple query APIs do not support references
    
+
    Section: 20.5.2.5 [tuple.helper] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-10-26
    
+
    View other active issues in [tuple.helper].
    
+
    View all other issues in [tuple.helper].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-Related issue: 408
+The tuple query APIs tuple_size and
+tuple_element do not support references-to-tuples.  This can be
+annoying when a template deduced a parameter type to be a reference,
+which must be explicitly stripped with remove_reference before calling
+these APIs.
 
    
-
-
    [
-Batavia (2009-05):
-]
    
-
-
    
-We believe this should be revisited
-in conjunction with issue 408,
-which nearly duplicates this issue.
-Move to Open.
-
    
-
-
    [
-2009-07 post-Frankfurt:
-]
    
-
-
-
    
 
    
-Change "constructed" to "initialized" in two places in the proposed resolution.
+I am not proposing a resolution at this point, as there is a
+combinatorial explosion with lvalue/rvalue references and
+cv-qualification (see previous issue) that suggests some higher
+refactoring is in order.  This might be something to kick back over to
+Core/Evolution.
 
    
 
    
-Move to Tentatively Ready.
+Note that we have the same problem in numeric_limits.
 
    
-
    
-
 
+
    [
+2009-10 post-Santa Cruz:
+]
    
 
-
    Proposed resolution:
    
-
    
-Change  [reverse.iter.con]:
-
    
 
-
    reverse_iterator();
-
    
 
    
--1- Effects: Default Value initializes current. Iterator
-operations applied to the resulting iterator have defined behavior if and
-only if the corresponding operations are defined on a default constructed
-value initialized
-iterator of type Iterator.
-
    
+Move to Open. Alisdair to provide wording.
 
    
 
-
    
-Change 24.5.2.2.1 [move.iter.op.const]:
-
    
 
-
    move_iterator();
-
    
-
    
--1- Effects: Constructs a move_iterator, default value
-initializing current.
-Iterator
-operations applied to the resulting iterator have defined behavior if and
-only if the corresponding operations are defined on a
-value initialized
-iterator of type Iterator.
-
    
-
    
 
+
    Proposed resolution:
    
 
 
 
 
 
 
    
-
    1019. Response to UK 205
    
-
    Section: 20.6.3 [meta.help] Status: Tentatively Ready
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
    
-
    View all other issues in [meta.help].
    
-
    View all issues with Tentatively Ready status.
    
+
    1121. Support for multiple arguments
    
+
    Section: 20.4.2 [ratio.arithmetic] Status: Tentatively NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-05-25  Last modified: 2009-11-02
    
+
    View all other issues in [ratio.arithmetic].
    
+
    View all issues with Tentatively NAD Future status.
    
 
    Discussion:
    
-
-
    Addresses UK 205
    
-
 
    
-integral_constant objects should be usable in integral-constant-expressions.
-The addition to the language of literal types and the enhanced rules for
-constant expressions make this possible.
+Both add and multiply could sensibly be called with more than two arguments.
+The variadic template facility makes such declarations simple, and is likely
+to be frequently wrapped by end users if we do not supply the variant
+ourselves.
+
    
+
    
+We deliberately ignore divide at this point as it is not transitive.
+Likewise, subtract places special meaning on the first argument so I do not
+suggest extending that immediately.  Both could be supported with analogous
+wording to that for add/multiply below.
+
    
+
    
+Note that the proposed resolution is potentially incompatible with that
+proposed for 921, although the addition of the typedef to ratio would be
+equally useful.
 
    
 
 
    [
-Batavia (2009-05):
-]
    
-
-
    
-We agree that the static data member
-ought be declared constexpr,
-but do not see a need for the proposed operator value_type().
-(A use case would be helpful.)
-Move to Open.
-
    
-
-
    [
-2009-05-23 Alisdair adds:
+2009-10-30 Alisdair adds:
 ]
    
 
 
 
    
 
    
-The motivating case in my mind is that we can then use
-true_type and false_type as integral Boolean expressions, for example inside
-a static_assert declaration.  In that sense it is purely a matter of style.
+The consensus of the group when we reviewed this in Santa Cruz was that
+921 would proceed to Ready as planned, and the
+multi-paramater add/multiply templates should be renamed as
+ratio_sum and ratio_product to avoid the problem
+mixing template aliases with partial specializations.
 
    
+
 
    
-Note that Boost has applied the non-explicit conversion operator for many
-years as it has valuable properties for extension into other metaprogramming
-libraries, such as MPL.  If additional rationale is desired I will poll the
-Boost lists for why this extension was originally applied.  I would argue
-that explicit conversion is more appropriate for 0x though.
+It was also suggested to close this issue as NAD Future as it does not
+correspond directly to any NB comment.  NBs are free to submit a
+specific comment (and re-open) in CD2 though.
 
    
-
    
-
-
    [
-2009-07-04 Howard adds:
-]
    
 
-
-
    
 
    
-Here's a use case which demonstrates the syntactic niceness which Alisdair describes:
+Walter Brown also had concerns on better directing the order of
+evaluation to avoid overflows if we do proceed for 0x rather than TR1,
+so wording may not be complete yet.
 
    
 
-
    #define requires(...) class = typename std::enable_if<(__VA_ARGS__)>::type
+
    [
+Alisdair updates wording.
+]
    
+
 
-template <class T, class U,
-    requires(!is_lvalue_reference<T>() ||
-              is_lvalue_reference<T>() && is_lvalue_reference<U>()),
-    requires(is_same<typename base_type<T>::type,
-                     typename base_type<U>::type>)>
-inline
-T&&
-forward(U&& t)
-{
-    return static_cast<T&&>(t);
-}
-
    
 
    
 
 
    [
-2009-07 post-Frankfurt:
+2009-10-30 Howard:
 ]
    
 
 
 
    
-Move to Tentatively Ready.
+Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
 
    
 
 
 
 
    Proposed resolution:
    
+
 
    
-Add to the integral_constant struct definition in 20.6.3 [meta.help]:
+Add the following type traits to p3 20.4 [ratio]
 
    
 
-
    template <class T, T v>
-struct integral_constant {
-  static constexpr T value = v;
-  typedef T value_type;
-  typedef integral_constant<T,v> type;
-  constexpr operator value_type() { return value; }
-};
+
    // ratio arithmetic
+template <class R1, class R2> struct ratio_add;
+template <class R1, class R2> struct ratio_subtract;
+template <class R1, class R2> struct ratio_multiply;
+template <class R1, class R2> struct ratio_divide;
+template <class R1, class ... RList> struct ratio_sum;
+template <class R1, class ... RList> struct ratio_product;
 
    
 
+
    
+after 20.4.2 [ratio.arithmetic] p1: add
+
    
 
+
    template <class R1, class ... RList> struct ratio_sum; // declared, never defined
 
+template <class R1> struct ratio_sum<R1> : R1 {};
+
    
 
+
    
+Requires: R1 is a specialization of class template ratio
+
    
 
-
    
-
    1020. Response to UK 204
    
-
    Section: 20.6.7 [meta.trans.other] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-03-12
    
-
    View other active issues in [meta.trans.other].
    
-
    View all other issues in [meta.trans.other].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    Addresses UK 204
    
-
-
    
-It is not possible to create a variant union based on a parameter pack
-expansion, e.g. to implement a classic discriminated union template. 
-
    
+
    template <class R1, class R2, class ... RList> 
+ struct ratio_sum<R1, R2, RList...>
+   : ratio_add< R1, ratio_sum<R2, RList...>> {
+};
+
    
 
-
    Original proposed resolutuion:
    
+
    
+Requires: R1 and each element in parmater pack
+RList is a specialization of class template ratio
+
    
+
    
 
 
    
-Restore aligned_union template that was removed by LWG issue 856. 
+after 20.4.2 [ratio.arithmetic] p3: add
 
    
 
-
    [
-Summit:
-]
    
+
    template <class R1, class ... RList> struct ratio_product; // declared, never defined
 
+template <class R1> struct ratio_product<R1> : R1 {};
+
    
 
 
    
-Agree. The need for aligned_union is compelling enough to reinstate.
+Requires: R1 is a specialization of class template ratio
 
    
 
-
    [
-Post Summit, Alisdair adds:
-]
    
-
+
    template <class R1, class R2, class ... RList> 
+ struct ratio_sum<R1, R2, RList...>
+   : ratio_add< R1, ratio_product<R2, RList...>> {
+};
+
    
 
 
    
-paper
-N2843
-proposes an extension to the [[align]] attribute
-that further diminishes the need for this template.  Recommend NAD.
+Requires: R1 and each element in parmater pack
+RList is a specialization of class template ratio
+
    
 
    
 
 
 
-
    Proposed resolution:
    
 
 
 
 
 
 
    
-
    1030. Response to JP 44
    
-
    Section: 20.8.10.6 [util.smartptr.shared.atomic] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
    
-
    View all issues with Open status.
    
+
    1123. no requirement that standard streams be flushed
    
+
    Section: 27.5.2.1.6 [ios::Init] Status: Ready
+ Submitter: James Kanze Opened: 2009-05-14  Last modified: 2009-10-20
    
+
    View all other issues in [ios::Init].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
-
    Addresses JP 44
    
-
-
    
-The 1st parameter p and 2nd parameter v is now
-shared_ptr<T>*.
-
    
 
    
-It should be shared_ptr<T>&, or if these are
-shared_ptr<T>* then add the "p shall not be a
-null pointer" at the requires.
+As currently formulated, the standard doesn't require that there 
+is ever a flush of cout, etc.  (This implies, for example, that 
+the classical hello, world program may have no output.)  In the 
+current draft
+(N2798),
+there is a requirement that the objects 
+be constructed before main, and before the dynamic 
+initialization of any non-local objects defined after the 
+inclusion of <iostream> in the same translation unit.  The only 
+requirement that I can find concerning flushing, however, is in 
+27.5.2.1.6 [ios::Init], where the destructor of the last 
+std::ios_base::Init object flushes.  But there is, as far as I 
+can see, no guarantee that such an object ever exists. 
+
    
+
    
+Also, the wording in  [iostreams.objects] says that:
+
    
+
    
+The objects 
+are constructed and the associations are established at some 
+time prior to or during the first time an object of class 
+ios_base::Init is constructed, and in any case before the body 
+of main begins execution.
+
    
+
    
+In 27.5.2.1.6 [ios::Init], however, as an 
+effect of the constructor, it says that
+
    
+
    
+If init_cnt is zero, 
+the function stores the value one in init_cnt, then constructs 
+and initializes the objects cin, cout, cerr, clog 
+wcin, wcout, wcerr, and wclog"
+
    
+
+
    
+which seems to forbid earlier 
+construction. 
+
    
+
+
    
+(Note that with these changes, the exposition only "static 
+int init_cnt" in ios_base::Init can be dropped.) 
+
    
+
    
+Of course, a determined programmer can still inhibit the 
+flush with things like: 
+
    
+
    new std::ios_base::Init ;       //  never deleted 
+
    
+
    
+or (in a function): 
+
    
+
    std::ios_base::Init ensureConstruction ; 
+//  ... 
+exit( EXIT_SUCCESS ) ; 
+
    
+
    
+Perhaps some words somewhere to the effect that all 
+std::ios_base::Init objects should have static lifetime 
+would be in order. 
 
    
 
 
    [
-Summit:
+2009 Santa Cruz:
 ]
    
 
 
 
    
-Agree. All of the functions need a requirement that p (or
-v) is a pointer to a valid object.
+Moved to Ready.  Some editorial changes are expected (in addition to the
+proposed wording) to remove init_cnt from Init.
 
    
 
-
    [
-2009-07 post-Frankfurt:
-]
    
 
 
-
    
+
    Proposed resolution:
    
 
    
-Lawrence explained that these signatures match the regular atomics. The
-regular atomics must not use references because these signatures are
-shared with C. The decision to pass shared_ptrs by pointer rather than
-by reference was deliberate and was motivated by the principle of least
-surprise.
+Change 27.4 [iostream.objects]/2:
 
    
+
+
    
+-2- The objects are constructed and the associations are established at
+some time prior to or during the first time an object of class
+ios_base::Init is constructed, and in any case before the body
+of main begins execution.292 The objects are not destroyed
+during program execution.293
+If a translation unit includes
+<iostream> or explicitly constructs an
+ios_base::Init object, these stream objects shall be
+constructed before dynamic initialization of non-local objects defined
+later in that translation unit.
+The results of including <iostream> in a translation
+unit shall be as if <iostream> defined an instance of
+ios_base::Init with static lifetime. Similarly, the entire
+program shall behave as if there were at least one instance of
+ios_base::Init with static lifetime.
+
    
+
 
    
-Lawrence to write wording that requires that the pointers not be null.
+Change 27.5.2.1.6 [ios::Init]/3:
 
    
+
+
    
+
    Init();
+
    
+
    
+-3- Effects: Constructs an object of class Init. 
+If init_cnt is zero, the function stores the value one in
+init_cnt, then constructs and initializes the objects
+cin, cout, cerr, clog (27.4.1),
+wcin, wcout, wcerr, and wclog
+(27.4.2). In any case, the function then adds one to the value stored in
+init_cnt.
+Constructs and initializes the objects cin, cout,
+cerr, clog, wcin, wcout,
+wcerr and wclog if they have not already been
+constructed and initialized.
+
    
 
    
 
+
    
+Change 27.5.2.1.6 [ios::Init]/4:
+
    
 
+
    
+
    ~Init();
+
    
+
    
+-4- Effects: Destroys an object of class Init.
+The function subtracts one from the value stored in init_cnt and,
+if the resulting stored value is one,
+If there are no other instances of the class still in
+existance,
+calls cout.flush(),
+cerr.flush(), clog.flush(), wcout.flush(),
+wcerr.flush(), wclog.flush().
+
    
+
    
 
-
    Proposed resolution:
    
 
 
 
 
 
 
    
-
    1031. Response to US 78
    
-
    Section: 20.8.10.2 [util.smartptr.shared] Status: Tentatively NAD Future
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-26
    
-
    View other active issues in [util.smartptr.shared].
    
-
    View all other issues in [util.smartptr.shared].
    
-
    View all issues with Tentatively NAD Future status.
    
+
    1125. ostream_iterator does not work with movable types
    
+
    Section: 24.6.2.2 [ostream.iterator.ops] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-05-30
    
+
    View all issues with New status.
    
 
    Discussion:
    
+
    
+ostream_iterator has not been updated to support moveable types, in a
+similar manner to the insert iterators.
+Note that this is not a problem for ostreambuf_iterator, as the types it is
+restricted to dealing with do not support extra-efficient moving.
+
    
 
-
    Addresses US 78
    
 
+
    Proposed resolution:
    
 
    
-There is presently no way to convert directly from a shared_ptr to a
-unique_ptr. Add an interface that performs the conversion. 
+Add second operator= overload to class template ostream_iterator
+in 24.6.2 [ostream.iterator], para 2:
 
    
 
-
    [
-Summit:
-]
    
+
    ostream_iterator<T,charT,traits>& operator=(const T& value);
+ostream_iterator<T,charT,traits>& operator=(T&& value);
+
    
 
+
    
+Add a new paragraph: in 24.6.2.2 [ostream.iterator.ops]:
+
    
 
 
    
-We look forward to a paper on this topic. We recommend no action until a
-paper is available. We believe that the shared pointer must use the default
-deleter for the conversion to succeed.
+
    ostream_iterator& operator=(T&& value);
+
    
+
    
+
    
+-2- Effects:
+
    
+
    *out_stream << std::move(value);
+if(delim != 0)
+  *out_stream << delim;
+return (*this);
+
    
+
    
 
    
 
-
    [
-Peter Dimov adds:
-]
    
 
 
-
    
-This is basically a request for shared_ptr<>::release in
-disguise, with all the associated problems. Not a good idea.
-
    
 
-
    [
-2009-07 post-Frankfurt:
-]
    
 
 
-
    
+
    
+
    1126. istreambuff_iterator::equal needs a const & parameter
    
+
    Section: 24.6.3.5 [istreambuf.iterator::equal] Status: Tentatively Ready
+ Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-11-02
    
+
    View all other issues in [istreambuf.iterator::equal].
    
+
    View all issues with Tentatively Ready status.
    
+
    Discussion:
    
 
    
-The rationale for the omission of a release() member function from shared_ptr is given in:
-http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm
+The equal member function of istreambuf_iterator is
+declared const, but takes its argument by non-const reference.
 
    
 
    
-The implementation of such a member is non-trivial (and maybe
-impossible), because it would need to account for the deleter.
+This is not compatible with the operator== free function overload, which is
+defined in terms of calling equal yet takes both arguments by reference to
+const.
 
    
-
    
 
 
    [
-2009-07-26 Howard sets to Tentatively NAD Future.
+The proposed wording is consistent with 110 with status TC1.
+]
    
+
+
+
    [
+2009-11-02 Howard adds:
 ]
    
 
 
 
    
+Set to Tentatively Ready after 5 positive votes on c++std-lib.
+
    
+
+
+
+
    Proposed resolution:
    
 
    
-I took an online poll and got 3 votes for NAD and 3 for NAD Future.  Personally
-I prefer NAD Future as this does refer to an extension that could conceivably be
-considered beyond C++0X.
+Ammend in both:
    
+24.6.3 [istreambuf.iterator]
    
+24.6.3.5 [istreambuf.iterator::equal]
    
 
    
 
+
    bool equal(const istreambuf_iterator& b) const;
+
    
+
+
+
+
+
+
+
    
+
    1130. copy_exception name misleading
    
+
    Section: 18.8.5 [propagation] Status: Review
+ Submitter: Peter Dimov Opened: 2009-05-13  Last modified: 2009-10-20
    
+
    View other active issues in [propagation].
    
+
    View all other issues in [propagation].
    
+
    View all issues with Review status.
    
+
    Discussion:
    
 
    
-However such an extension would need to solve a couple of problems:
+The naming of std::copy_exception misleads almost everyone
+(experts included!) to think that it is the function that copies an
+exception_ptr:
 
    
 
-
      
-
    1. What is the interface for such a conversion when the shared_ptr does
-not have unique ownership?  Throw an exception?  Create a null unique_ptr?
-Undefined behavior?
-
      2. 
+
      exception_ptr p1 = current_exception();
+exception_ptr p2 = copy_exception( p1 );
+
      
 
-
    2. 
 
      
-How does one handle custom deleters given to the shared_ptr constructor?
+But this is not at all what it does. The above actually creates an
+exception_ptr p2 that contains a copy of p1, not of
+the exception to which p1 refers!
 
      
 
      
-I do not believe it is possible to implement a general answer to this question.
-The shared_ptr deleter is a run time (or construction time) characteristic.
-The unique_ptr deleter is a compile time characteristic.  In general one
-can not know to what type of unqiue_ptr you are converting to.
+This is, of course, all my fault; in my defence, I used copy_exception
+because I was unable to think of a better name.
 
      
 
      
-One answer is for the user of the conversion to specify the deleter type and perhaps
-throw an exception if the specification turns out to be incorrect.
+But I believe that, based on what we've seen so far, any other name would be better.
 
      
 
      
-Another answer is for the conversion to only be valid when the underlying deleter
-is default_delete.  We would probalby need to specify that this is indeed the
-underlying deleter of a shared_ptr when a custom deleter is not given in
-the constructor.
+Therefore, I propose copy_exception to be renamed to
+create_exception:
 
      
-
      3. 
-
    
+
+
    template<class E> exception_ptr create_exception(E e);
+
    
 
 
    
-At any rate, there are non-trivial design issues which would need to be implemented
-and tested in the field for usability prior to standardization.
+with the following explanatory paragraph after it:
 
    
-
    
-
 
+
    
+Creates an exception_ptr that refers to a copy of e.
+
    
 
-
    Proposed resolution:
    
+
    [
+2009-05-13 Daniel adds:
+]
    
 
 
+
    
+
    
+What about
+
    
+
    make_exception_ptr
+
    
+
    
+in similarity to make_pair and make_tuple, make_error_code and
+make_error_condition, or make_shared? Or, if a stronger symmetry to
+current_exception is preferred:
+
    
 
-
-
-
    
-
    1033. thread::join() effects?
    
-
    Section: 30.3.1.5 [thread.thread.member] Status: Open
- Submitter: Alberto Ganesh Barbati Opened: 2009-03-12  Last modified: 2009-05-23
    
-
    View other active issues in [thread.thread.member].
    
-
    View all other issues in [thread.thread.member].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    
-While looking at thread::join() I think I spotted a couple of
-possible defects in the specifications. I could not find a previous
-issue or NB comment about that, but I might have missed it.
-
    
-
-
    
-The postconditions clause for thread::join() is:
-
    
-
-
    
-Postconditions: If join() throws an exception, the value
-returned by get_id() is unchanged. Otherwise, get_id() == id().
-
    
-
-
    
-and the throws clause is:
-
    
-
-
    
-Throws: std::system_error when the postconditions cannot be achieved.
-
    
-
-
    
-Now... how could the postconditions not be achieved?
-It's just a matter of resetting the value of get_id() or leave it
-unchanged! I bet we can always do that. Moreover, it's a chicken-and-egg
-problem: in order to decide whether to throw or not I depend on the
-postconditions, but the postconditions are different in the two cases.
-
    
-
+
    make_exception
+
    
 
    
-I believe the throws clause should be:
+We have not a single create_* function in the library, it was always
+make_* used.
 
    
-
-
    
-Throws: std::system_error when the effects or postconditions
-cannot be achieved.
 
    
 
-
    
-as it is in detach(), or, even better, as the postcondition is
-trivially satisfiable and to remove the circular dependency:
-
    
+
    [
+2009-05-13 Peter adds:
+]
    
 
 
 
    
-Throws: std::system_error if the effects cannot be achieved.
+make_exception_ptr works for me.
 
    
 
-
    
-Problem is that... ehm... join() has no "Effects" clause. Is that intentional?
-
    
-
 
    [
-See the thread starting at c++std-lib-23204 for more discussion.
+2009-06-02 Thomas J. Gritzan adds:
 ]
    
 
 
-
    [
-Batavia (2009-05):
-]
    
-
 
    
 
    
-Pete believes there may be some more general language (in frontmatter)
-that can address this and related issues such as 962.
+To avoid surprises and unwanted recursion, how about making a call to
+std::make_exception_ptr with an exception_ptr illegal?
 
    
 
    
-Move to Open.
+It might work like this:
 
    
+
    template<class E>
+exception_ptr make_exception_ptr(E e);
+template<>
+exception_ptr make_exception_ptr<exception_ptr>(exception_ptr e) = delete;
+
    
 
    
 
-
-
    Proposed resolution:
    
-
-
+
    [
+2009 Santa Cruz:
+]
    
 
 
+
    
+Move to Review for the time being. The subgroup thinks this is a good
+idea, but doesn't want to break compatibility unnecessarily if someone
+is already shipping this. Let's talk to Benjamin and PJP tomorrow to
+make sure neither objects.
+
    
 
-
    
-
    1034. Response to UK 222
    
-
    Section: 23.2.1 [container.requirements.general] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
    
-
    View other active issues in [container.requirements.general].
    
-
    View all other issues in [container.requirements.general].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
 
-
    Addresses UK 222
    
 
+
    Proposed resolution:
    
 
    
-It is not clear what purpose the Requirement tables serve in the
-Containers clause. Are they the definition of a library Container? Or
-simply a conventient shorthand to factor common semantics into a single
-place, simplifying the description of each subsequent container? This
-becomes an issue for 'containers' like array, which does not meet the
-default-construct-to-empty requirement, or forward_list which does not
-support the size operation. Are these components no longer containers?
-Does that mean the remaining requirements don't apply? Or are these
-contradictions that need fixing, despite being a clear design decision?
+Change 18.8.5 [propagation]:
 
    
 
-
    
-Recommend:
-
    
+
    
+
    template<class E> exception_ptr copy_exceptionmake_exception_ptr(E e);
+
    
 
+
    
 
    
-Clarify all the tables in 23.2 [container.requirements] are
-there as a convenience for documentation, rather than a strict set of
-requirements. Containers should be allowed to relax specific
-requirements if they call attention to them in their documentation. The
-introductory text for array should be expanded to mention a
-default constructed array is not empty, and
-forward_list introduction should mention it does not provide
-the required size operation as it cannot be implemented
-efficiently.
+-11- Effects: Creates an exception_ptr that refers
+to a copy of e, as if
 
    
 
-
    [
-Summit:
-]
    
-
+
    try {
+  throw e;
+} catch(...) {
+  return current_exception();
+}
+
    
 
-
    
-Agree in principle.
+
    ...
    
 
    
 
-
    [
-2009-07 post-Frankfurt:
-]
    
-
-
-
    
-We agree in principle, but we have a timetable. This group feels that
-the issue should be closed as NAD unless a proposed resolution is
-submitted prior to the March 2010 meeting.
 
    
 
 
 
-
    Proposed resolution:
    
-
-
 
 
 
 
    
-
    1035. Response to UK 226
    
-
    Section: 23.2.1 [container.requirements.general] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-08-01
    
-
    View other active issues in [container.requirements.general].
    
-
    View all other issues in [container.requirements.general].
    
-
    View all issues with Open status.
    
+
    1131. C++0x does not need alignment_of
    
+
    Section: 20.6.4.3 [meta.unary.prop] Status: New
+ Submitter: Niels Dekker Opened: 2009-06-01  Last modified: 2009-06-02
    
+
    View other active issues in [meta.unary.prop].
    
+
    View all other issues in [meta.unary.prop].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses UK 226
    
-
 
    
-<array> must be added to this list. In particular it
-doesn't satisfy: - no swap() function invalidates any
-references, pointers, or iterators referring to the elements of the
-containers being swapped. and probably doesn't satisfy: - no
-swap() function throws an exception.
+The alignment_of template is no longer necessary, now that the
+core language will provide alignof. Scott Meyers raised this
+issue at comp.std.c++,
+C++0x: alignof vs. alignment_of,
+May 21, 2009.  In a reply, Daniel Krügler pointed out that
+alignof was added to the working paper after
+alignment_of. So it appears that alignment_of is only
+part of the current Working Draft 
+(N2857)
+because it is in TR1.
 
    
 
    
-If <array> remains a container, this will have to also
-reference array, which will then have to say which of these
-points it satisfies.
+Having both alignof and alignment_of would cause
+unwanted confusion. In general, I think TR1 functionality should not be
+brought into C++0x if it is entirely redundant with other C++0x language
+or library features.
 
    
 
-
    [
-Summit:
-]
    
-
-
-
    
-Agree. The proposed resolution is incomplete. Further work required.
-
    
-
-
    [
-2009-05-01 Daniel adds:
-]
    
-
-
-
    
-Issue 1099 also suggests
-adding move constructor to this.
-
    
-
-
    [
-2009-07 post-Frankfurt:
-]
    
-
-
-
    
-Howard is to draft a note that explains what happens to references.
-
    
-
-
-
-
    [
-2009-08-01 Howard provided wording.
-]
    
-
 
 
    Proposed resolution:
    
 
    
-Add a paragraph to 23.3.1.2 [array.special]:
+Remove from Header <type_traits> synopsis 20.6.2 [meta.type.synop]:
 
    
+
    template <class T> struct alignment_of;
+
    
 
-
    template <Swappable T, size_t N> void swap(array<T,N>& x, array<T,N>& y);
-
    
-
    
 
    
-Effects:
+Remove the first row of Table 34 ("Type property queries"), from
+Type properties 20.6.4.3 [meta.unary.prop]:
 
    
-
    swap_ranges(x.begin(), x.end(), y.begin());
-
    
-
-
    
-[Note:
-Outstanding iterators, references and pointers may be invalidated.
-— end note]
-
    
+
    
+
+
+
+
+
+
+
    Table 34 -- Type property queries
    template <class T> struct alignment_of;alignof(T).
    
+Precondition: T shall be a complete type, a reference
+type, or an array of unknown bound, but shall not be a function type or
+(possibly cv-qualified) void.
+
    
 
    
+
+
    
+Change text in Table 41 ("Other transformations"), from Other
+transformations 20.6.7 [meta.trans.other], as follows:
+
    
+
    
+
+
+
+
+
+
    Table 41 -- Other transformations
    ...
+ Align shall be equal to 
+ alignment_of<T>::value
+ alignof(T)
+  for some type T or to default-alignment.
+...
    
 
    
 
 
@@ -23338,293 +19537,122 @@ Outstanding iterators, references and pointers may be invalidated.
 
 
 
    
-
    1041. Response to UK 239
    
-
    Section: 23.2.4 [associative.reqmts] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
    
-
    View all other issues in [associative.reqmts].
    
-
    View all issues with Open status.
    
+
    1133. Does N2844 break current specification of list::splice?
    
+
    Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-05-09  Last modified: 2009-10-27
    
+
    View all other issues in [forwardlist.ops].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses UK 239
    
-
 
    
-It is not possible to take a move-only key out of an unordered
-container, such as (multi)set or
-(multi)map, or the new unordered containers.
+IIUC,
+N2844
+means that lvalues will no longer bind to rvalue references.
+Therefore, the current specification of list::splice (list
+operations 23.3.4.4 [list.ops]) will be a breaking change of behaviour for existing
+programs.  That is because we changed the signature to swallow via an rvalue
+reference rather than the lvalue reference used in 03.
 
    
-
 
    
-Add below a.erase(q), a.extract(q), with the following notation:
+Retaining this form would be safer, requiring an explicit move when splicing
+from lvalues.  However, this will break existing programs.
+We have the same problem with forward_list, although without the risk of
+breaking programs so here it might be viewed as a positive feature.
 
    
 
    
-a.extract(q)>, Return type pair<key, iterator>
-Extracts the element pointed to by q and erases it from the
-set. Returns a pair containing the value pointed to by
-q and an iterator pointing to the element immediately
-following q prior to the element being erased. If no such
-element exists,returns a.end().
+The problem signatures:
 
    
+
    void splice_after(const_iterator position, forward_list<T,Alloc>&& x);
+void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
+                  const_iterator i);
+void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
+                  const_iterator first, const_iterator last);
 
-
    [
-Summit:
-]
    
-
-
-
    
-We look forward to a paper on this topic. We recommend no action until a
-paper is available. The paper would need to address exception safety.
-
    
-
-
    [
-Post Summit Alisdair adds:
-]
    
-
-
-
    
-Would value_type be a better return type than key_type?
-
    
-
-
    [
-2009-07 post-Frankfurt:
-]
    
-
-
-
    
-Leave Open. Alisdair to contact Chris Jefferson about this.
-
    
-
+void splice(const_iterator position, list<T,Alloc>&& x);
+void splice(const_iterator position, list<T,Alloc>&& x,
+            const_iterator i);
+void splice(const_iterator position, list<T,Alloc>&& x,
+            const_iterator first, const_iterator last);
+
    
 
+Possible resolutions:
 
-
    Proposed resolution:
    
 
    
-In 23.2.4 [associative.reqmts] Table 85, add:
+Option A.   Add an additional (non-const) lvalue-reference
+overload in each case
 
    
-
-
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    Table 85 --  Associative container requirements (in addition to container)
    ExpressionReturn typeAssertion/note
    pre-/post-condition    		Complexity
    a.erase(q).........
    a.extract(q)pair<key_type, iterator>Extracts the element pointed to by q and erases it from the set. 
-Returns a pair containing the value pointed to by q and an iterator
-pointing to the element immediately following q prior to the element being
-erased. If no such element 
-exists, returns a.end().amortized constant
    
-
    
-
 
    
-In 23.2.5 [unord.req] Table 87, add:
+Option B.   Change rvalue reference back to (non-const)
+lvalue-reference overload in each case
 
    
-
-
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    Table 87 -- Unordered associative container requirements (in addition to container)
    ExpressionReturn typeAssertion/note
    pre-/post-condition    		Complexity
    a.erase(q).........
    a.extract(q)pair<key_type, iterator>Extracts the element pointed to by q and erases it from the set. 
-Returns a pair containing the value pointed to by q and an iterator
-pointing to the element immediately following q prior to the element being
-erased. If no such element 
-exists, returns a.end().amortized constant
    
-
    
-
-
-
-
-
-
    
-
    1042. Response to UK 244
    
-
    Section: 23.3 [sequences] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
    
-
    View all other issues in [sequences].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    Addresses UK 244
    
-
 
    
-The validity of the expression &a[n] == &a[0] + n is contingent on
-operator& doing the "right thing" (as captured by the CopyConstructible
-requirements in table 30 in C++2003). However this constraint has been
-lost in the Concepts of C++0x. This applies to vector and array (it
-actually applies to string also, but that's a different chapter, so I'll
-file a separate comment there and cross-reference).
+Option C.   Add an additional (non-const) lvalue-reference
+overload in just the std::list cases
+
    
+
    
+I think (B) would be very unfortunate, I really like the forward_list
+behaviour in (C) but feel (A) is needed for consistency.
 
    
-
 
    
-Suggested solution:
+My actual preference would be NAD, ship with this as a breaking change as it
+is a more explicit interface.  I don't think that will fly though!
 
    
 
 
    
-Define a ContiguousStrorage and apply it to
-vector, array and string.
+See the thread starting with c++std-lib-23725 for more discussion.
 
    
 
 
    [
-Summit:
-]
    
-
-
-
    
-Agree with the issue but not the details of the proposed solution. Walter to
-provide wording for the new concept.
-
    
-
-
    [
-Post Summit Alisdair adds:
-]
    
-
-
-
    
-Another LWG subgroup wondered if this concept
-should extend to complex<T>, and so not be built on the container concept at
-all?
-
    
-
-
    [
-2009-07 post-Frankfurt:
+2009-10-27 Christopher Jefferson provides proposed wording for Option C.
 ]
    
 
 
-
    
-Leave Open, pending a post-Concepts Working Draft.
-
    
-
-
 
 
    Proposed resolution:
    
 
    
-Add to <container_concepts> synopsis in 23.2.6 [container.concepts]
-
    
-
-
    concept< typename C > ContiguousStorageContainer see below;
-
    
-
-
    
-Add a new section to the end of 23.2.6 [container.concepts]
-
    
-
-
    
-
    
-23.1.6.x ContiguousStorageContainer concept [container.concepts.contiguous]
+In 23.3.4 [list]
 
    
 
-
    concept ContiguousStorageContainer< typename C >
-  : Container<C>
-{
-  value_type* data(C&);
-
-  axiom Contiguity(C& c, size_type i) {
-    if( i < size(c) ) {
-         addressof( * (data(c) + i) )
-      == addressof( * advance(data(c), i) );
-    }
-  }
-}
-
    
-
 
    
-The ContiguousStorageContainer concept describes a container whose elements
-are allocated in a single region of memory, and are stored sequentially
-without intervening padding other than to meet alignment requirements.
-For example, the elements may be stored in a
-single array of suitable length.
+Add lvalue overloads before rvalue ones:
 
    
 
-
    value_type * data( C& );
-
    
-
-
    
-Returns: a pointer to the first element in the region of storage.
-Result is unspecified for an empty container.
-
    
-
-
    
+
    void splice(const_iterator position, list<T,Allocator>& x);
+void splice(const_iterator position, list<T,Allocator>&& x);
+void splice(const_iterator position, list<T,Allocator>& x, const_iterator i);
+void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i);
+void splice(const_iterator position, list<T,Allocator>& x,
+            const_iterator first, const_iterator last);
+void splice(const_iterator position, list<T,Allocator>&& x,
+            const_iterator first, const_iterator last);
+
    
 
 
    
-Change 23.3.1 [array] p1:
+In 23.3.4.4 [list.ops], similarly add lvalue overload before each rvalue one:
 
    
-
-
    
--1- The header <array> defines a class template for
-storing fixed-size sequences of objects. An array supports
-random access iterators. An instance of array<T, N>
-stores N elements of type T, so that size() ==
-N is an invariant. The elements of an array are stored
-contiguously, meaning that if a is an
-array<T, N> then it obeys the identity &a[n]
-== &a[0] + n for all 0 <= n < N
-satisfies the concept ContiguousStorageContainer< array<T,
-N>>.
-
    
-
 
    
-Add to the synopsis in 23.3.1 [array]:
+(After paragraph 2)
 
    
 
-
        ...
-    T * data(); 
-    const T * data() const; 
-  };
-
-  template< typename T, size_t N >
-    concept_map ContiguousStorageContainer< array<T, N>> {};
-} 
+
    void splice(const_iterator position, list<T,Allocator>& x);
+void splice(const_iterator position, list<T,Allocator>&& x);
 
    
 
 
    
-Change 23.3.6 [vector] p1:
+(After paragraph 6)
 
    
 
-
    
-A vector is a sequence container that supports random access
-iterators. In addition, it supports (amortized) constant time insert and
-erase operations at the end; insert and erase in the middle take linear
-time. Storage management is handled automatically, though hints can be
-given to improve efficiency. The elements of a vector are stored
-contiguously, meaning that if v is a
-vector<T, Alloc> (where T is some
-type other than bool), then it obeys the
-identity &v[n] == &v[0] + n for all 0 <= n <
-v.size() satisfies the concept ContiguousStorageContainer<
-vector< T, Alloc>>.
-
    
+
    void splice(const_iterator position, list<T,Allocator>& x, const_iterator i);
+void splice(const_iterator position, list<T,Allocator>&& x, const_iterator i);
+
    
 
 
    
-Add at the end of the synopsis in 23.3.6 [vector] p2:
+(After paragraph 10)
 
    
 
-
    template< typename T, typename A >
-  requires !SameType< T, bool >
-  concept_map ContiguousStorageContainer< vector<T, A>> {};
+
    void splice(const_iterator position, list<T,Allocator>& x,
+            const_iterator first, const_iterator last);
+void splice(const_iterator position, list<T,Allocator>&& x,
+            const_iterator first, const_iterator last);
 
    
 
 
@@ -23633,951 +19661,749 @@ Add at the end of the synopsis in 23.3.6 [vector] p2:
 
 
 
    
-
    1043. Response to US 91
    
-
    Section: 29.6 [atomics.types.operations] Status: Review
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
    
-
    View other active issues in [atomics.types.operations].
    
-
    View all other issues in [atomics.types.operations].
    
-
    View all issues with Review status.
    
+
    1134. Redundant specification of stdint.h, fenv.h, tgmath.h, and maybe complex.h
    
+
    Section: 18.4.2 [stdinth], 26.3.2 [fenv], 26.8 [c.math], 26.4.11 [cmplxh] Status: Ready
+ Submitter: Robert Klarer Opened: 2009-05-26  Last modified: 2009-10-20
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
-
    Addresses US 91
    
-
 
    
-It is unclear whether or not a failed compare_exchange is a RMW operation
-(as used in 1.10 [intro.multithread]).
+This is probably editorial.
 
    
-
 
    
-Suggested solution:
+The following items should be removed from the draft, because they're
+redundant with Annex D, and they arguably make some *.h headers
+non-deprecated:
 
    
-
 
    
-Make failing compare_exchange operations not be RMW.
+18.4.2 [stdinth] (regarding <stdint.h>) 
+
    
+
    
+26.3.2 [fenv] (regarding <fenv.h>
+
    
+
    
+Line 3 of 26.8 [c.math] (regarding <tgmath.h>) 
+
    
+
    
+26.4.11 [cmplxh] (regarding <complex.h>, though the note in this subclause is not redundant) 
 
    
 
 
    [
-Anthony Williams adds:
-]
    
-
-
-
    
-In 29.6 [atomics.types.operations] p18 it says that "These
-operations are atomic read-modify-write operations" (final sentence).
-This is overly restrictive on the implementations of
-compare_exchange_weak and compare_exchange_strong on platforms without a
-native CAS instruction.
-
    
-
-
-
    [
-Summit:
+2009-06-10 Ganesh adds:
 ]
    
 
 
 
    
-Group agrees with the resolution as proposed by Anthony Williams in the attached note.
-
    
-
-
    [
-Batavia (2009-05):
-]
    
-
-
    
-We recommend the proposed resolution be reviewed
-by members of the Concurrency Subgroup.
+While searching for stdint in the CD, I found that <stdint.h> is also
+mentioned in 3.9.1 [basic.fundamental] /5. It guess it should refer to
+<cstdint> instead.
 
    
 
 
    [
-2009-07 post-Frankfurt:
+2009 Santa Cruz:
 ]
    
 
 
 
    
-This is likely to be addressed by Lawrence's upcoming paper. He will
-adopt the proposed resolution.
+Real issue. Maybe just editorial, maybe not. Move to Ready.
 
    
 
 
 
 
    Proposed resolution:
    
 
    
-Change 29.6 [atomics.types.operations] p18:
+Remove the section 18.4.2 [stdinth].
+
    
+
    
+Remove the section 26.3.2 [fenv].
+
    
+
    
+Remove 26.8 [c.math], p3:
 
    
 
 
    
--18- Effects: Atomically, compares the value pointed to by
-object or by this for equality with that in
-expected, and if true, replaces the value pointed to by
-object or by this with desired, and if false, updates
-the value in expected with the value pointed to by
-object or by this. Further, if the comparison is true,
-memory is affected according to the value of success, and if the
-comparison is false, memory is affected according to the value of
-failure. When only one memory_order argument is
-supplied, the value of success is order, and the value
-of failure is order except that a value of
-memory_order_acq_rel shall be replaced by the value
-memory_order_acquire and a value of
-memory_order_release shall be replaced by the value
-memory_order_relaxed. If the comparison is true, 
-Tthese operations are atomic
-read-modify-write operations (1.10). 
-If the comparison is false, these
-operations are atomic load operations.
+-3- The header <tgmath.h> effectively includes the headers <complex.h>
+and <math.h>.
 
    
-
+
    
+Remove the section 26.4.11 [cmplxh].
+
    
 
 
 
 
 
 
    
-
    1046. Response to UK 329
    
-
    Section: 30.6 [futures] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-03-13
    
-
    View all issues with Open status.
    
+
    1135. exception_ptr should support contextual conversion to bool
    
+
    Section: 18.8.5 [propagation] Status: Ready
+ Submitter: Daniel Krügler Opened: 2007-06-06  Last modified: 2009-10-20
    
+
    View other active issues in [propagation].
    
+
    View all other issues in [propagation].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
-
    Addresses UK 329
    
-
 
    
-future, promise and packaged_task provide a
-framework for creating future values, but a simple function to tie all
-three components together is missing. Note that we only need a *simple*
-facility for C++0x. Advanced thread pools are to be left for TR2.
+As of
+N2857
+18.8.5 [propagation]/5, the implementation-defined type
+exception_ptr does provide the following ways to check whether
+it is a null value:
 
    
-
+
    void f(std::exception_ptr p) {
+  p == nullptr;
+  p == 0;
+  p == exception_ptr();
+}
+
    
 
    
-Simple Proposal:
+This is rather cumbersome way of checking for the null value
+and I suggest to require support for evaluation in a boolean
+context like so:
 
    
 
-
    
-Provide a simple function along the lines of: 
-
    
-
    template< typename F, typename ... Args >
-  requires Callable< F, Args... >
-    future< Callable::result_type > async( F&& f, Args && ... ); 
+
    void g(std::exception_ptr p) {
+  if (p) {}
+  !p;
+}
 
    
 
-
    
-Semantics are similar to creating a thread object with a packaged_task
-invoking f with forward<Args>(args...)
-but details are left unspecified to allow different scheduling and thread
-spawning implementations. 
-
    
-
    
-It is unspecified whether a task submitted to async is run on its own thread
-or a thread previously used for another async task. If a call to async
-succeeds, it shall be safe to wait for it from any thread. 
-
    
-
    
-The state of thread_local variables shall be preserved during async calls. 
-
    
-
    
-No two incomplete async tasks shall see the same value of
-this_thread::get_id(). 
-
    
-
    
-[Note: this effectively forces new tasks to be run on a new thread, or a
-fixed-size pool with no queue. If the 
-library is unable to spawn a new thread or there are no free worker threads
-then the async call should fail. --end note] 
-
    
-
 
    [
-Summit:
+2009 Santa Cruz:
 ]
    
 
 
 
    
-
    
-The concurrency subgroup has revisited this issue and decided that it
-could be considered a defect according to the Kona compromise. A task
-group was formed lead by Lawrence Crowl and Bjarne Stroustrup to write a
-paper for Frankfort proposing a simple asynchronous launch facility
-returning a future. It was agreed that the callable must be run on a
-separate thread from the caller, but not necessarily a brand-new thread.
-The proposal might or might not allow for an implementation that uses
-fixed-size or unlimited thread pools.
-
    
-
    
-Bjarne in c++std-lib-23121: I think that what we agreed was that to
-avoid deadlock async() would almost certainly be specified to  launch in
-a different thread from the thread that executed async(), but I don't
-think it was a specific design constraint.
-
    
+Move to Ready. Note to editor: considering putting in a cross-reference
+to 4 [conv], paragraph 3, which defines the phrase
+"contextually converted to bool".
 
    
 
 
 
 
    Proposed resolution:
    
-
-
-
-
-
-
    
-
    1047. Response to UK 334
    
-
    Section: 30.6.5 [futures.unique_future] Status: Review
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-05-23
    
-
    View other active issues in [futures.unique_future].
    
-
    View all other issues in [futures.unique_future].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
-
-
    Addresses UK 334
    
-
 
    
-Behaviour of get() is undefined if calling get() while
-not is_ready(). The intent is that get() is a blocking
-call, and will wait for the future to become ready.
+In section 18.8.5 [propagation] insert a new paragraph between p.5 and p.6:
 
    
 
-
    [
-Summit:
-]
    
-
-
 
    
-
    
-Agree, move to Review.
-
    
+
+An object e of type exception_ptr can be contextually converted to bool.
+The effect shall be as if e != exception_ptr() had been evaluated in place
+of e. There shall be no implicit conversion to arithmetic type, to
+enumeration type or to pointer type.
+
 
    
 
-
    [
-2009-04-03 Thomas J. Gritzan adds:
-]
    
 
 
-
    
-
    
-This issue also applies to shared_future::get().
-
    
 
-
    
-Suggested wording:
-
    
 
+
    
+
    1136. Incomplete specification of nested_exception::rethrow_nested()
    
+
    Section: 18.8.6 [except.nested] Status: Ready
+ Submitter: Daniel Krügler Opened: 2007-06-06  Last modified: 2009-10-20
    
+
    View other active issues in [except.nested].
    
+
    View all other issues in [except.nested].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
 
    
-Add a paragraph to  [futures.shared_future]:
+It was recently mentioned in a newsgroup article
+http://groups.google.de/group/comp.std.c++/msg/f82022aff68edf3d
+that the specification of the member function rethrow_nested() of the
+class nested_exception is incomplete, specifically it remains unclear
+what happens, if member nested_ptr() returns a null value. In
+18.8.6 [except.nested] we find only the following paragraph related to that:
 
    
-
-
    void shared_future<void>::get() const;
+
    void rethrow_nested() const; // [[noreturn]]
 
    
 
    
-Effects: If is_ready() would return false, block on the asynchronous 
-result associated with *this.
-
    
+-4- Throws: the stored exception captured by this nested_exception object.
 
    
 
    
+
    
+This is a problem, because it is possible to create an object of
+nested_exception with exactly such a state, e.g.
+
    
+
    #include <exception>
+#include <iostream>
+
+int main() try {
+  std::nested_exception e; // OK, calls current_exception() and stores it's null value
+  e.rethrow_nested(); // ?
+  std::cout << "A" << std::endl;
+}
+catch(...) {
+  std::cout << "B" << std::endl;
+}
+
    
+
    
+I suggest to follow the proposal of the reporter, namely to invoke
+terminate() if nested_ptr() return a null value of exception_ptr instead
+of relying on the fallback position of undefined behavior. This would
+be consistent to the behavior of a throw; statement when no
+exception is being handled.
+
    
 
 
    [
-Batavia (2009-05):
+2009 Santa Cruz:
 ]
    
 
+
 
    
-It is not clear to us that this is an issue,
-because the proposed resolution's Effects clause seems to duplicate
-information already present in the Synchronization clause.
-Keep in Review status.
+Move to Ready.
 
    
 
 
+
 
    Proposed resolution:
    
 
    
-Add a paragraph to 30.6.5 [futures.unique_future]:
+Change around 18.8.6 [except.nested]/4 as indicated:
 
    
-
-
    R&& unique_future::get(); 
-R& unique_future<R&>::get(); 
-void unique_future<void>::get();
-
    
 
    
-
    Note:...
    
 
    
-Effects: If is_ready() would return false,
-block on the asynchronous result associated with *this.
+-4- Throws: the stored exception captured by this nested_exception
+object, if nested_ptr() != nullptr
 
    
 
    
-Synchronization: if *this is associated with a
-promise object, the completion of set_value() or
-set_exception() to that promise happens before (1.10)
-get() returns.
+- Remarks: If nested_ptr() == nullptr, terminate()
+shall be called.
 
    
 
    
-
    
 
 
 
 
 
 
    
-
    1048. Response to UK 335
    
-
    Section: 30.6.5 [futures.unique_future] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-03-13
    
-
    View other active issues in [futures.unique_future].
    
-
    View all other issues in [futures.unique_future].
    
-
    View all issues with Open status.
    
+
    1137. Return type of conj and proj
    
+
    Section: 26.4.9 [cmplx.over] Status: New
+ Submitter: Marc Steinbach Opened: 2009-06-11  Last modified: 2009-06-27
    
+
    View all other issues in [cmplx.over].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses UK 335
    
-
 
    
-std::unique_future is MoveConstructible, so you can transfer the
-association with an asynchronous result from one instance to another.
-However, there is no way to determine whether or not an instance has
-been moved from, and therefore whether or not it is safe to wait for it.
+In clause 1, the Working Draft 
+(N2857)
+specifies overloads of the
+functions
 
    
-
-
    std::promise<int> p;
-std::unique_future<int> uf(p.get_future());
-std::unique_future<int> uf2(std::move(uf));
-uf.wait(); // oops, uf has no result to wait for. 
+
    arg, conj, imag, norm, proj, real
 
    
-
 
    
-Suggest we add a waitable() function to unique_future
-(and shared_future) akin to std::thread::joinable(),
-which returns true if there is an associated result to wait for
-(whether or not it is ready).
+for non-complex arithmetic types (float, double,
+long double, and integers).
+The only requirement (clause 2) specifies effective type promotion of arguments.
 
    
-
 
    
-Then we can say:
+I strongly suggest to add the following requirement on the return types:
 
    
-
-
    if(uf.waitable()) uf.wait();
-
    
-
-
    [
-Summit:
-]
    
-
-
 
    
-
    
-Create an issue. Requires input from Howard. Probably NAD.
-
    
+All the specified overloads must return real (i.e., non-complex) values,
+specifically, the nested value_type of effectively promoted arguments.
 
    
 
-
    [
-Post Summit, Howard thows in his two cents:
-]
    
-
-
-
    
 
    
-Here is a copy/paste of my last prototype of unique_future which was
-several years ago.  At that time I was calling unique_future future:
+(This has no effect on arg, imag, norm, real:
+they are real-valued anyway.)
+
    
+
    Rationale:
    
+
    
+Mathematically, conj() and proj(), like the transcendental functions, are
+complex-valued in general but map the (extended) real line to itself.
+In fact, both functions act as identity on the reals.
+A typical user will expect conj() and proj() to preserve this essential
+mathematical property in the same way as exp(), sin(), etc.
+A typical use of conj(), e.g., is the generic scalar product of n-vectors:
 
    
 
-
    template <class R>
-class future
-{
-public:
-    typedef R result_type;
-private:
-    future(const future&);// = delete;
-    future& operator=(const future&);// = delete;
-
-    template <class R1, class F1> friend class prommise;
-public:
-    future();
-    ~future();
-
-    future(future&& f);
-    future& operator=(future&& f);
-
-    void swap(future&& f);
-
-    bool joinable() const;
-    bool is_normal() const;
-    bool is_exceptional() const;
-    bool is_ready() const;
-
-    R get();
-
-    void join();
-    template <class ElapsedTime>
-        bool timed_join(const ElapsedTime&);
-};
+
    template<typename T>
+inline T
+scalar_product(size_t n, T const* x, T const* y) {
+  T result = 0;
+  for (size_t i = 0; i < n; ++i)
+    result += x[i] * std::conj(y[i]);
+  return result;
+}
 
    
-
 
    
-shared_future had a similar interface.  I intentionally reused
-the thread interface where possible to lessen the learning
-curve std::lib clients will be faced with.
+This will work equally well for real and complex floating-point types T if
+conj() returns T. It will not work with real types if conj()
+returns complex values.
+
    
+
    
+Instead, the implementation of scalar_product becomes either less efficient
+and less useful (if a complex result is always returned), or unnecessarily
+complicated (if overloaded versions with proper return types are defined).
+In the second case, the real-argument overload of conj() cannot be used.
+In fact, it must be avoided.
+
    
+
    
+Overloaded conj() and proj() are principally needed in generic programming.
+All such use cases will benefit from the proposed return type requirement,
+in a similar way as the scalar_product example.
+The requirement will not harm use cases where a complex return value
+is expected, because of implicit conversion to complex.
+Without the proposed return type guarantee, I find overloaded versions
+of conj() and proj() not only useless but actually troublesome.
 
    
-
    
 
 
 
 
    Proposed resolution:
    
+
    
+Insert a new paragraph after 26.4.9 [cmplx.over]/2:
+
    
+
+
    
+
+All of the specified overloads shall have a return type which is the nested value_type of
+the effectively promoted arguments.
+
+
    
 
 
 
 
 
 
    
-
    1049. Response to UK 339
    
-
    Section: 30.6.4 [futures.promise] Status: Review
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-05-23
    
-
    View other active issues in [futures.promise].
    
-
    View all other issues in [futures.promise].
    
-
    View all issues with Review status.
    
+
    1138. unusual return value for operator+
    
+
    Section: 21.4.8.1 [string::op+] Status: Tentatively Ready
+ Submitter: Alisdair Meredith Opened: 2009-06-12  Last modified: 2009-11-05
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
+
    
+Many of the basic_string operator+ overloads return an rvalue-reference.  Is
+that really intended?
+
    
+
    
+I'm considering it might be a mild performance tweak to avoid making
+un-necessary copies of a cheaply movable type, but it opens risk to dangling
+references in code like:
+
    
 
-
    Addresses UK 339
    
+
    auto && s = string{"x"} + string{y};
+
    
 
 
    
-Move assignment is goiing in the wrong direction, assigning from
-*this to the passed rvalue, and then returning a reference to
-an unusable *this.
+and I'm not sure about:
 
    
 
+
    auto s = string{"x"} + string{y};
+
    
+
 
    [
-Summit:
+2009-10-11 Howard updated Returns: clause for each of these.
 ]
    
 
 
-
    
-
    
-Agree, move to Review.
-
    
-
    
-
 
    [
-Batavia (2009-05):
+2009-11-05 Howard adds:
 ]
    
 
+
 
    
-We recommend deferring this issue until after Detlef's paper (on futures)
-has been issued.
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.
 
    
 
 
 
    Proposed resolution:
    
 
    
-Strike 30.6.4 [futures.promise] p6 and change p7:
+Strike the && from the return type in the following function
+signatures:
 
    
 
-
    promise& operator=(promise&& rhs);
-
    
 
    
 
    
--6- Effects: move assigns its associated state to rhs.
-
    
-
    
--7- Postcondition: *this has no associated
-state. associated state of *this is the same as the
-associated state of rhs before the call. rhs has no
-associated state.
+21.3 [string.classes] p2 Header Synopsis
 
    
-
    
-
    
 
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs,
+              const basic_string<charT,traits,Allocator>& rhs);
+
+template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(const basic_string<charT,traits,Allocator>& lhs,
+              basic_string<charT,traits,Allocator>&& rhs);
 
+template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs,
+              basic_string<charT,traits,Allocator>&& rhs);
 
 
+template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(const charT* lhs,
+              basic_string<charT,traits,Allocator>&& rhs);
 
+template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);
 
-
    
-
    1050. Response to UK 340
    
-
    Section: 30.6.4 [futures.promise] Status: Review
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-05-23
    
-
    View other active issues in [futures.promise].
    
-
    View all other issues in [futures.promise].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
+template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs,
+              const charT* rhs);
 
-
    Addresses UK 340
    
+template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);
+
    
 
 
    
-There is an implied postcondition for get_future() that the state of the
-promise is transferred into the future leaving the promise with no
-associated state. It should be spelled out.
+21.4.8.1 [string::op+]
 
    
 
-
    [
-Summit:
-]
    
-
-
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs,
+              const basic_string<charT,traits,Allocator>& rhs);
+
    
 
    
-
    
-Agree, move to Review.
-
    
+Returns: std::move(lhs.append(rhs))
 
    
-
-
    [
-2009-04-03 Thomas J. Gritzan adds:
-]
    
-
-
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(const basic_string<charT,traits,Allocator>& lhs,
+              basic_string<charT,traits,Allocator>&& rhs);
+
    
 
    
-
    
-promise::get_future() must not invalidate the state of the promise object. 
-
    
-
    
-A promise is used like this: 
-
    
-
    promise<int> p; 
-unique_future<int> f = p.get_future(); 
-// post 'p' to a thread that calculates a value 
-// use 'f' to retrieve the value. 
-
    
-
    
-So get_future() must return an object that shares the same associated 
-state with *this. 
-
    
-
    
-But still, this function should throw an future_already_retrieved error 
-when it is called twice. 
-
    
-
    
-packaged_task::get_future() throws std::bad_function_call if its future
-was already retrieved. It should throw 
-future_error(future_already_retrieved), too. 
-
    
-
    
-Suggested resolution: 
-
    
-
    
-Replace p12/p13 30.6.4 [futures.promise]: 
-
    
+Returns: std::move(rhs.insert(0, lhs))
+
    
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs,
+              basic_string<charT,traits,Allocator>&& rhs);
+
    
 
    
-
    
--12- Throws: future_error if *this has no associated state
-the future has already been retrieved.
-
    
-
    
--13- Error conditions: future_already_retrieved if *this
-has no associated state
-the future associated with 
-the associated state has already been retrieved.
-
    
-
    
-Postcondition: The returned object and *this share the associated state.
-
    
+Returns: std::move(lhs.append(rhs)) [Note: Or equivalently
+std::move(rhs.insert(0, lhs)) — end note]
 
    
-
    
-Replace p14 30.6.7 [futures.task]: 
-
    
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(const charT* lhs,
+              basic_string<charT,traits,Allocator>&& rhs);
+
    
 
    
-
    
--14- Throws: std::bad_function_call future_error if the future associated with
-the task has already been retrieved.
-
    
-
-
    
-Error conditions: future_already_retrieved if the future associated with 
-the task has already been retrieved. 
-
    
-
    
-Postcondition: The returned object and *this share the associated task.
-
    
+Returns: std::move(rhs.insert(0, lhs)).
 
    
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);
+
    
+
    
+Returns: std::move(rhs.insert(0, 1, lhs)).
 
    
-
-
    [
-Batavia (2009-05):
-]
    
-
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs,
+              const charT* rhs);
+
    
 
    
-Keep in Review status
-pending Detlef's forthcoming paper on futures.
+Returns: std::move(lhs.append(rhs)).
 
    
-
-
-
    Proposed resolution:
    
-
    
-Add after p13 30.6.4 [futures.promise]:
-
    
-
-
    unique_future<R> get_future();
+
    template<class charT, class traits, class Allocator>
+  basic_string<charT,traits,Allocator>&&
+    operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);
 
    
 
    
-
    
--13- ...
-
    
-
    
-Postcondition: *this has no associated state.
-
    
+Returns: std::move(lhs.append(1, rhs)).
 
    
 
    
 
+
    
+
 
 
 
 
 
 
    
-
    1051. Response to UK 279
    
-
    Section: 24.5.1.2.12 [reverse.iter.opindex], 24.5.2.2.12 [move.iter.op.index] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-27
    
-
    View all issues with Open status.
    
+
    1144. "thread safe" is undefined
    
+
    Section: 18.5 [support.start.term] Status: Ready
+ Submitter: LWG Opened: 2009-06-16  Last modified: 2009-10-20
    
+
    View all other issues in [support.start.term].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
-
    Addresses UK 279
    
+
    Addresses UK 187
    
 
 
    
-The reason the return type became unspecified is LWG issue 386. This
-reasoning no longer applies as there are at least two ways to get the right
-return type with the new language facilities added since the previous
-standard. 
+The term "thread safe" is not defined nor used in this context
+anywhere else in the standard.
 
    
 
+
    Suggested action:
    
 
    
-Proposal: Specify the return type using either decltype or the Iter concept_map.
+Clarify the meaning of "thread safe".
 
    
 
 
    [
-Summit:
+2009 Santa Cruz:
 ]
    
 
 
 
    
 
    
-Under discussion. This is a general question about all iterator
-adapters.
+The "thread safe" language has already been change in the WP. It was
+changed to "happen before", but the current WP text is still a little
+incomplete: "happen before" is binary, but the current WP text only
+mentions one thing.
+
    
+
    
+Move to Ready.
 
    
 
    
 
-
    [
-Howard adds post Summit:
-]
    
-
-
-
    
-I am requesting test cases to demonstrate a position.
-
    
-
-
    [
-2009-07-24 Daniel adds:
-]
    
 
 
-
    
+
    Proposed resolution:
    
 
    
-I recommend NAD. Without concepts we can no longer
-restrict this member in a trivial way. Using decltype the
-declaration would be along the lines of
+For the following functions in 18.5 [support.start.term].
 
    
-
    static const Iter& __base(); // not defined
-auto operator[](difference_type n) const -> decltype(__base()[-n-1]);
-
    
+
    
+extern "C" int at_quick_exit(void (*f)(void));
+extern "C++" int at_quick_exit(void (*f)(void));
+
    
 
 
    
-but once reverse_iterator is instantiated for some given type
-Iter which cannot form a well-formed expression __base()[-n-1]
-this would cause an ill-formed function declaration, diagnostic
-required, and no silent SFINAE elimination.
+Edit paragraph 10 as follows.
+The intent is
+to provide the other half of the happens before relation;
+to note indeterminate ordering;
+and to clean up some formatting.
 
    
+
    
+Effects:
+The at_quick_exit() functions
+register the function pointed to by f
+to be called without arguments when quick_exit is called.
+It is unspecified whether a call to at_quick_exit()
+that does not happen-before happen before (1.10)
+all calls to quick_exit
+will succeed.
+[Note:
+the at_quick_exit() functions
+shall not introduce a data race (17.6.4.7).
+exitnote
+—end note]
+
+[Note:
+The order of registration may be indeterminate
+if at_quick_exit was called from more than one thread.
+—end note]
+
+[Note: The at_quick_exit registrations
+are distinct from the atexit registrations,
+and applications may need to call both registration functions
+with the same argument.
+—end note]
+
    
 
-
    
-
-
+
    
+For the following function.
+
    
+
    
+void quick_exit [[noreturn]] (int status)
+
    
 
-
    Proposed resolution:
    
+
    
+Edit paragraph 13 as follows.
+The intent is to note that thread-local variables may be different.
+
    
+
    
+Effects:
+Functions registered by calls to at_quick_exit
+are called in the reverse order of their registration,
+except that a function shall be called
+after any previously registered functions
+that had already been called at the time it was registered.
+Objects shall not be destroyed as a result of calling quick_exit.
+If control leaves a registered function called by quick_exit
+because the function does not provide a handler for a thrown exception,
+terminate() shall be called.
+
+[Note:
+Functions registered by one thread may be called by any thread,
+and hence should not rely on the identity of thread-storage-duration objects.
+—end note]
+
+After calling registered functions,
+quick_exit shall call _Exit(status).
+[Note:
+The standard file buffers are not flushed.
+See: ISO C 7.20.4.4.
+—end note]
+
    
 
 
 
 
 
 
    
-
    1052. Response to UK 281
    
-
    Section: 24.5.1.2.5 [reverse.iter.opref] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-08-01
    
+
    1151. Behavior of the library in the presence of threads is incompletely specified
    
+
    Section: 17 [library] Status: Open
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-20
    
+
    View other active issues in [library].
    
+
    View all other issues in [library].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
+
    Addresses US 63
    
 
-
    Addresses UK 281
    
-
-
    
-The current specification for return value for reverse_iterator::operator->
-will always be a true pointer type, but reverse_iterator supports proxy
-iterators where the pointer type may be some kind of 'smart pointer'.
+   
    Description
    
+        
    The behavior of the library in the presence of threads
+        is incompletely specified.
    
+        
    For example, if thread 1 assigns to X, then writes data
+        to file f, which is read by thread 2, and then accesses
+        variable X, is thread 2 guaranteed to be able to see the
+        value assigned to X by thread 1? In other words, does the
+        write of the data "happen before" the read?
    
+        
    Another example: does simultaneous access using operator
+        at() to different characters in the same non-const string
+        really introduce a data race?
    
+
    Suggestion
    
+
    Notes
    17 SG: should go to threads group; misclassified in document
 
    
 
+    
    Concurrency SG: Create an issue. Hans will look into it.
    
+
 
    [
-Summit:
+2009 Santa Cruz:
 ]
    
 
 
 
    
-
    
-move_iterator avoids this problem by returning a value of the wrapped
-Iterator type.
-study group formed to come up with a suggested resolution.
-
    
-
    
-move_iterator solution shown in proposed wording.
-
    
+Move to "Open". Hans and the rest of the concurrency working group will
+study this. We can't make progress without a thorough review and a
+paper.
 
    
 
-
    [
-2009-07 post-Frankfurt:
-]
    
-
 
-
    
-Howard to deconceptize. Move to Review after that happens.
-
    
 
-
    [
-2009-08-01 Howard deconceptized:
-]
    
+
    Proposed resolution:
    
 
 
-
    
-
    
 
 
 
-
    Proposed resolution:
    
+
    
+
    1152. expressions parsed differently than intended
    
+
    Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: Tentatively Ready
+ Submitter: Seungbeom Kim Opened: 2009-06-27  Last modified: 2009-10-28
    
+
    View other active issues in [facet.num.put.virtuals].
    
+
    View all other issues in [facet.num.put.virtuals].
    
+
    View all issues with Tentatively Ready status.
    
+
    Discussion:
    
 
    
-Change synopsis in 24.5.1.1 [reverse.iterator]:
+In Table 73 -- Floating-point conversions, 22.4.2.2.2 [facet.num.put.virtuals], 
+in
+N2914,
+we have the following entries: 
 
    
+
+
+
+
+
+
+
+
+
 
-
    template <class Iterator> 
-class reverse_iterator { 
-  ...
-  typedef typename iterator_traits<Iterator>::pointer pointer;
-
    
+
+
+
+
+
    Table 73 — Floating-point conversions
    State stdio equivalent
    floatfield == ios_base::fixed | ios_base::scientific && !uppercase%a
    floatfield == ios_base::fixed | ios_base::scientific%A
    
 
 
    
-Change 24.5.1.2.5 [reverse.iter.opref]:
+These expressions are supposed to mean: 
 
    
 
-
    pointer operator->() const;
-
    
-
    
-Returns:
-
    &(operator*());
-this->tmp = current;
---this->tmp;
-return this->tmp;
+
    floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase 
+floatfield == (ios_base::fixed | ios_base::scientific) 
 
    
-
    
-
    
-
-
-
-
-
-
-
    
-
    1053. Response to UK 295
    
-
    Section: 25 [algorithms] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-03-13
    
-
    View other active issues in [algorithms].
    
-
    View all other issues in [algorithms].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    Addresses UK 295
    
-
 
    
-There is a level of redundancy in the library specification for many
-algorithms that can be eliminated with the combination of concepts and
-default parameters for function templates. Eliminating redundancy simplified
-specification and reduces the risk of introducing accidental
-inconsistencies.
+but technically parsed as: 
 
    
+
    ((floatfield == ios_base::fixed) | ios_base::scientific) && (!uppercase) 
+((floatfield == ios_base::fixed) | ios_base::scientific) 
+
    
 
    
-Proposed resolution: Adopt
-N2743.
+and should be corrected with additional parentheses, as shown above. 
 
    
 
 
    [
-Summit:
+2009-10-28 Howard:
 ]
    
 
 
 
    
-
    
-NAD, this change would break code that takes the address of an
-algorithm.
-
    
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.
 
    
 
-
    [
-Post Summit Alisdair adds:
-]
    
 
 
-
    
+
    Proposed resolution:
    
 
    
-Request 'Open'.  The issues in the paper go beyond just reducing
-the number of signatures, but cover unifying the idea of the ordering
-operation used by algorithms, containers and other library components.  At
-least, it takes a first pass at the problem.
+Change Table 83 — Floating-point conversions in  22.4.2.2.2 [facet.num.put.virtuals]:
 
    
 
-
    
-For me (personally) that was the more important part of the paper, and not
-clearly addressed by the Summit resolution.
-
    
-
    
+
+
+
+
+
+
+
+
+
 
-
-
-
    Proposed resolution:
    
+
+
+
+
+
    Table 83 — Floating-point conversions
    State stdio equivalent
    floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase%a
    floatfield == (ios_base::fixed | ios_base::scientific)%A
    
 
 
 
 
 
 
    
-
    1054. forward broken
    
-
    Section: 20.3.2 [forward] Status: Open
- Submitter: Howard Hinnant Opened: 2009-03-13  Last modified: 2009-08-02
    
-
    View other active issues in [forward].
    
-
    View all other issues in [forward].
    
+
    1153. Standard library needs review for constructors to be
+explicit to avoid treatment as initializer-list constructor
    
+
    Section: 17 [library], 30 [thread], D [depr] Status: Open
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-20
    
+
    View other active issues in [library].
    
+
    View all other issues in [library].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
 
-
    
-This is a placeholder issue to track the fact that we (well I) put the standard
-into an inconsistent state by requesting that we accept
-N2844
-except for the proposed changes to [forward].
-
    
-
-
    
-There will exist in the post meeting mailing
-N2835
-which in its current state reflects the state of affairs prior to the Summit
-meeting.  I hope to update it in time for the post Summit mailing, but as I write
-this issue I have not done so yet.
-
    
+
    Addresses DE 2
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    Description
    
+        
    Marking a constructor with explicit has semantics
+        even for a constructor with zero or several parameters:
+        Such a constructor cannot be used with list-initialization
+        in a copy-initialization context, see 13.3.1.7 [over.match.list]. The
+        standard library apparently has not been reviewed for
+        marking non-single-parameter constructors as explicit.
    
+
    Suggestion
    
+        
    Consider marking zero-parameter and multi-parameter
+        constructors explicit in classes that have at least one
+        constructor marked explicit and that do not have an
+        initializer-list constructor.
    
 
-
    
-Move to Open, awaiting the promised paper.
-
    
+
    Notes
    
+        
    Robert Klarer to address this one.
    
 
 
    [
-2009-08-02 Howard adds:
+2009 Santa Cruz:
 ]
    
 
 
 
    
-
    
-My current preferred solution is:
-
    
-
-
    template <class T>
-struct __base_type
-{
-   typedef typename remove_cv<typename remove_reference<T>::type>::type type;
-};
-
-template <class T, class U,
-   class = typename enable_if<
-       !is_lvalue_reference<T>::value ||
-        is_lvalue_reference<T>::value &&
-        is_lvalue_reference<U>::value>::type,
-   class = typename enable_if<
-        is_same<typename __base_type<T>::type,
-                typename __base_type<U>::type>::value>::type>
-inline
-T&&
-forward(U&& t)
-{
-   return static_cast<T&&>(t);
-}
-
    
-
-
    
-This has been tested by Bill, Jason and myself.
-
    
-
-
    
-It allows the following lvalue/rvalue casts:
-
    
-
-
      
-
    1. 
-Cast an lvalue t to an lvalue T (identity).
-
      2. 
-
    2. 
-Cast an lvalue t to an rvalue T.
-
      3. 
-
    3. 
-Cast an rvalue t to an rvalue T (identity).
-
      4. 
-
    
-
-
    
-It disallows:
-
    
-
-
      
-
    1. 
-Cast an rvalue t to an lvalue T.
-
      2. 
-
    2. 
-Cast one type t to another type T (such as int to double).
-
      3. 
-
    
-
-
    
-"a." is disallowed as it can easily lead to dangling references.
-"b." is disallowed as this function is meant to only change the lvalue/rvalue
-characteristic of an expression.
-
    
-
-
    
-Jason has expressed concern that "b." is not dangerous and is useful in contexts
-where you want to "forward" a derived type as a base type.  I find this use case
-neither dangerous, nor compelling.  I.e. I could live with or without the "b."
-constraint.  Without it, forward would look like:
-
    
-
-
    template <class T, class U,
-   class = typename enable_if<
-       !is_lvalue_reference<T>::value ||
-        is_lvalue_reference<T>::value &&
-        is_lvalue_reference<U>::value>::type>
-inline
-T&&
-forward(U&& t)
-{
-   return static_cast<T&&>(t);
-}
-
    
-
-
    
-Or possibly:
-
    
-
-
    template <class T, class U,
-   class = typename enable_if<
-       !is_lvalue_reference<T>::value ||
-        is_lvalue_reference<T>::value &&
-        is_lvalue_reference<U>::value>::type,
-   class = typename enable_if<
-        is_base_of<typename __base_type<U>::type,
-                   typename __base_type<T>::type>::value>::type>
-inline
-T&&
-forward(U&& t)
-{
-   return static_cast<T&&>(t);
-}
-
    
-
-
-
    
-The "promised paper" is not in the post-Frankfurt mailing only because I'm waiting
-for the non-concepts draft.  But I'm hoping that by adding this information here
-I can keep people up to date.
-
    
+Move to "Open". Robert Klarer has promised to provide wording.
 
    
 
 
@@ -24589,160 +20415,74 @@ I can keep people up to date.
 
 
 
    
-
    1055. Response to UK 98
    
-
    Section: 20.6.7 [meta.trans.other] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-05-23
    
-
    View other active issues in [meta.trans.other].
    
-
    View all other issues in [meta.trans.other].
    
-
    View all issues with Open status.
    
+
    1154. complex should accept integral types
    
+
    Section: 26.4 [complex.numbers] Status: New
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
    
+
    View all other issues in [complex.numbers].
    
+
    View all issues with New status.
    
 
    Discussion:
    
 
-
    Addresses UK 98
    
-
-
    
-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.
-
    
-
-
    [
-Batavia (2009-05):
-]
    
+
    Addresses FR 35
    
 
-
    
-Pete observes (and Tom concurs)
-that the proposed resolution seems to require compiler support
-for its implementation,
-as it seems necessary to look at the range of values
-of the enumerated type.
-To a first approximation,
-a library solution could give an answer based on the size of the type.
-If the user has specialized numeric_limits for the enumerated type,
-then the library might be able to do better,
-but there is no such requirement.
-Keep status as Open
-and solicit input from CWG.
-
    
+
    Description
    
+        
    Instantiations of the class
+        template complex<> have to be allowed for integral
+        types, to reflect existing practice and ISO standards
+        (LIA-III).
    
+        
+
    Suggestion
    
 
 
    [
-2009-05-23 Alisdair adds:
+2009-10-26 Proposed wording in
+N3002.
 ]
    
 
 
-
    
-Just to confirm that the BSI originator of this comment assumed it did
-indeed imply a compiler intrinsic.  Rather than request a Core extension, it
-seemed in keeping with that the type traits interface provides a library API
-to unspecified compiler features - where we require several other traits
-(e.g. has_trivial_*) to get the 'right' answer now, unlike in TR1.
-
    
 
 
 
    Proposed resolution:
    
-
    
-Add a new row to the table in 20.6.7 [meta.trans.other]:
-
    
-
-
    
-
-
-
-
-
-
-
-
-
-
-
-
-
    Table 41 -- Other transformations
    TemplateConditionComments
    
-template< class T > struct enum_base;
-
-T shall be an enumeration type (7.2 [dcl.enum])
-
-The member typedef type shall name the underlying type
-of the enum T.
-
    
-
    
+Adopt
+N3002.
 
 
 
 
 
 
    
-
    1056. Must all Engines and Distributions be Streamable?
    
-
    Section: 26.5 [rand] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-05-31
    
-
    View all other issues in [rand].
    
+
    1156. Constraints on bitmask and enumeration types to be tightened
    
+
    Section: 17.5.2.1.2 [enumerated.types], 17.5.2.1.3 [bitmask.types] Status: Open
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-27
    
 
    View all issues with Open status.
    
 
    Discussion:
    
 
-
    
-Both the concepts RandomNumberEngine and RandomNumberDistribution have
-requirements to be InputStreamable and OutputStreamable.
-
    
-
    
-I have no problems leaving the WP in an inconsistent state on the best-faith
-assumption these concepts will be provided later, however disagree with the
-proposers that these constraints are not separable, orthogonal to the basic
-concepts of generating random number distributions.
-
    
-
    
-These constraints should be dropped, and applied to specific algorithms as
-needed.
-
    
-
    
-If a more refined concept (certainly deemed useful by the proposers) is
-proposed there is no objection, but the basic concept should not require
-persistence via streaming.
-
    
-
-
    [
-Batavia (2009-05):
-]
    
+
    Addresses UK 165
    
 
-
    
-Move to Open.
-
    
+
    Description
    
+        
    Constraints on
+        bitmask and enumeration types were supposed to be tightened
+        up as part of the motivation for the constexpr feature -
+        see paper
+        N2235
+        for details
    
+
    Suggestion
    
+        
    Adopt wording in line with the motivation
+        described in
+        N2235
    
+
    Notes
    
+        
    Robert Klarer to review
    
 
 
    [
-2009-05-31 Alisdair adds:
+2009 Santa Cruz:
 ]
    
 
 
 
    
-
    
-Working on constraining the stream iterators, I have a few more observations
-to make on the concepts proposed while constraining the random number
-facility.
-
    
-
    
-While I still believe the concerns are orthogonal, I don't believe the
-existing constraints go far enough either!  The goal we want to achieve is
-not that a RandomNumberEngine / RandomNumberDistribution supports the stream
-operators, but that it is Serializable.  I.e. there is a relationship
-between the insert and extract operations that guarantees to restore the
-state of the original object.  This implies a coupling of the concepts
-together in a broader concept (Serializable) with at least one axiom to
-assert the semantics.
-
    
-
    
-One problem is that istream and ostream may be fundamentally different
-types, although we can hook a relation if we are prepared to drop down to
-the char type and char_traits template parameters.  Doing so ties us to a
-form of serialization that demands implementation via the std iostreams
-framework, which seems overly prescriptive.  I believe the goal is generally
-to support serialization without regard to how it is expressed - although
-this is getting even more inventive in terms of concepts we do not have
-today.
-
    
+Move to Open. Ping Robert Klarer to provide wording, using N2235 as
+guidance.
 
    
 
 
+
 
    Proposed resolution:
    
 
 
@@ -24750,137 +20490,192 @@ today.
 
 
 
    
-
    1062. Missing insert_iterator for stacks/queues
    
-
    Section: 24.7 [insert.iterators] Status: Tentatively NAD Future
- Submitter: Alisdair Meredith Opened: 2009-03-13  Last modified: 2009-07-29
    
-
    View other active issues in [insert.iterators].
    
-
    View all other issues in [insert.iterators].
    
-
    View all issues with Tentatively NAD Future status.
    
+
    1157. Local types can now instantiate templates
    
+
    Section: 17.6.3.2.1 [namespace.std] Status: Ready
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-21
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
-
    
-It is odd that we have an iterator to insert into a vector, but not an
-iterator to insert into a vector that is adapted as a stack. The standard
-container adapters all have a common interface to push and pop so it should
-be simple to create an iterator adapter to complete the library support.
-
    
+
    Addresses UK 175
    
 
-
    
-We should provide an AdaptedContainer concept supporting push and pop
-operations. Create a new insert iterator and factory function that inserts
-values into the container by calling push.
-
    
+
    Description
    
+        
    Local types can
+        now be used to instantiate templates, but don't have
+        external linkage.
    
+
    Suggestion
    
+        
    Remove the reference to external linkage.
    
+
+
    Notes
    
+
    We accept the proposed solution. Martin will draft an issue.
    
 
 
    [
-Batavia (2009-05):
+2009-07-28 Alisdair provided wording.
 ]
    
 
-
    
-
    
-Walter recommends NAD Future.
-
    
-
    
-Move to Open, and recommend deferring the issue until after the next
-Committee Draft is issued.
-
    
-
    
 
 
    [
-2009-07-29 Howard moves to Tentatively NAD Future.
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-A poll on the LWG reflector voted unanimously to move this issue to Tentatively NAD Future.
+Moved to Ready.
 
    
 
 
-
    Proposed resolution:
    
-
-
-
-
-
-
    
-
    1064. Response to UK 152
    
-
    Section: 17.3.15 [defns.obj.state] Status: Open
- Submitter: Howard Hinnant Opened: 2009-03-15  Last modified: 2009-03-15
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
-
    Addresses UK 152
    
 
+
    Proposed resolution:
    
 
    
-Object state is using a definition of object (instance of a class) from
-outside the standard, rather than the 'region of storage' definiton in
-1.8 [intro.object]p1
+17.6.3.2.1 [namespace.std]
+
    
+
    
+Strike "of external linkage" in p1 and p2:
 
    
 
-
    [
-Summit:
-]
    
-
 
    
-We think we're removing this; See X [func.referenceclosure.cons].
-
    
-
+
    
+-1- The behavior of a C++ program is undefined if it adds declarations or
+definitions to namespace std or to a namespace within namespace std
+unless otherwise specified. A program may add a concept map for any
+standard library concept or a template specialization for any standard
+library template to namespace std only if the declaration depends on a
+user-defined type of external linkage and the specialization meets the
+standard library requirements for the original template and is not
+explicitly prohibited.179
+
    
 
-
    Proposed resolution:
    
 
    
+-2- The behavior of a C++ program is undefined if it declares
+
    
+
      
+
    • 
+an explicit specialization of any member function of a standard library
+class template, or
+
      • 
+
    • 
+an explicit specialization of any member function template of a standard
+library class or class template, or
+
      • 
+
    • 
+an explicit or partial specialization of any member class template of a
+standard library class or class template.
+
      • 
+
    
+
    
+A program may explicitly instantiate a template defined in the standard
+library only if the declaration depends on the name of a user-defined
+type of external linkage and the instantiation meets the standard
+library requirements for the original template.
 
    
+
    
+
 
 
 
 
 
 
    
-
    1068. class random_device should be movable
    
-
    Section: 26.5.6 [rand.device] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-18  Last modified: 2009-05-23
    
-
    View all other issues in [rand.device].
    
-
    View all issues with Open status.
    
+
    1158. Encouragement to use monotonic clock
    
+
    Section: 30.2.4 [thread.req.timing] Status: Tentatively Ready
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-31
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
-
    
-class random_device should be movable.
-
    
+
    Addresses UK 322, US 96
    
+
+
    Description
    
+        
    Not all systems
+        can provide a monotonic clock. How are they expected to
+        treat a _for function?
    
+
    Suggestion
    
+        
    Add at least a note explaining the intent
+        for systems that do not support a monotonic clock.
    
+
+
    Notes
    
+
    Create an issue, together with UK 96. Note that the specification as is 
+    already allows a non-monotonic clock due to the word “should” rather than 
+    “shall”. If this wording is kept, a footnote should be added to make the 
+    meaning clear.
    
+
+
    [ 2009-06-29 Beman provided a proposed resolution. ] 
    
 
 
    [
-Batavia (2009-05):
+2009-10-31 Howard adds:
 ]
    
 
+
 
    
-Move to Open, and recommend this issue be deferred until after the next
-Committee Draft is issued.
+Set to Tentatively Ready after 5 positive votes on c++std-lib.
 
    
 
 
+
 
    Proposed resolution:
    
 
+
    Change Timing specifications 30.2.4 [thread.req.timing] as indicated:
    
+
+
    The member functions whose names end in _for take an argument that
+specifies a relative time. Implementations
+should are encouraged but not required to use a
+monotonic clock to measure time for these functions.
    
+
+
 
 
 
 
 
    
-
    1069. class seed_seq should support efficient move operations
    
-
    Section: 26.5.7.1 [rand.util.seedseq] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-18  Last modified: 2009-05-23
    
-
    View all other issues in [rand.util.seedseq].
    
-
    View all issues with Open status.
    
+
    1159. Unclear spec for resource_deadlock_would_occur
    
+
    Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: New
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-04
    
+
    View other active issues in [thread.lock.unique.locking].
    
+
    View all other issues in [thread.lock.unique.locking].
    
+
    View all issues with New status.
    
 
    Discussion:
    
 
-
    
-class seed_seq should support efficient move operations.
-
    
+
    Addresses UK 327, UK 328
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    UK 327 Description
    
+        
    Not clear what
+        the specification for error condition
+        resource_deadlock_would_occur means. It is perfectly
+        possible for this thread to own the mutex without setting
+        owns to true on this specific lock object. It is also
+        possible for lock operations to succeed even if the thread
+        does own the mutex, if the mutex is recursive. Likewise, if
+        the mutex is not recursive and the mutex has been locked
+        externally, it is not always possible to know that this
+        error condition should be raised, depending on the host
+        operating system facilities. It is possible that 'i.e.' was
+        supposed to be 'e.g.' and that suggests that recursive
+        locks are not allowed. That makes sense, as the
+        exposition-only member owns is boolean and not a integer to
+        count recursive locks.
    
+        
+
    UK 327 Suggestion
    
+        
    Add a precondition !owns. Change the 'i.e.'
+        in the error condition to be 'e.g.' to allow for this
+        condition to propogate deadlock detection by the host OS.
    
+
    UK 327 Notes
    
+
    Create an issue. Assigned to Lawrence Crowl. Note: not sure what try_lock 
+    means for recursive locks when you are the owner. POSIX has language on 
+    this, which should ideally be followed. Proposed fix is not quite right, for 
+    example, try_lock should have different wording from lock.
    
 
-
    
-Move to Open, and recommend this issue be deferred until after the next
-Committee Draft is issued.
-
    
+
    UK 328 Description
    
+
+        
    There is a missing precondition that owns
+        is true, or an if(owns) test is missing from the effect
+        clause
    
+
    UK 328 Suggestion
    
+        
    Add a
+        precondition that owns == true. Add an error condition to
+        detect a violation, rather than yield undefined behaviour.
    
+
    UK 328 Notes
    
+
    Handle in same issue as UK 327. Also uncertain that the proposed resolution 
+    is the correct one.
    
+
+    
 
 
 
    Proposed resolution:
    
@@ -24890,791 +20685,335 @@ Committee Draft is issued.
 
 
 
    
-
    1071. is_bind_expression should derive from integral_constant<bool>
    
-
    Section: 20.7.12.1.1 [func.bind.isbind] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-19  Last modified: 2009-05-31
    
-
    View all issues with Open status.
    
+
    1169. num_get not fully compatible with strto*
    
+
    Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: New
+ Submitter: Cosmin Truta Opened: 2009-07-04  Last modified: 2009-07-07
    
+
    View other active issues in [facet.num.get.virtuals].
    
+
    View all other issues in [facet.num.get.virtuals].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
 
    
-Class template is_bind_expression 20.7.12.1.1 [func.bind.isbind]:
+As specified in the latest draft,
+N2914,
+num_get is still not fully compatible with the following C
+functions: strtoul, strtoull, 
+strtof and
+strtod.
 
    
-
-
    namespace std {
-  template<class T> struct is_bind_expression {
-    static const bool value = see below;
-  };
-}
-
    
 
    
-is_bind_expression should derive from std::integral_constant<bool> like
-other similar trait types.
+In C, when conversion of a string to an unsigned integer type falls 
+outside the
+representable range, strtoul and strtoull return
+ULONG_MAX and ULLONG_MAX, respectively, 
+regardless
+whether the input field represents a positive or a negative value.
+On the other hand, the result of num_get conversion of 
+negative
+values to unsigned integer types is zero. This raises a compatibility 
+issue.
 
    
-
-
    [
-Daniel adds:
-]
    
-
-
    
-We need the same thing for the trait is_placeholder as well.
-
    
-
    [
-2009-03-22 Daniel provided wording.
-]
    
-
-
-
    [
-Batavia (2009-05):
-]
    
-
-
    
 
    
-We recommend this be deferred until after the next Committee Draft is issued.
+Moreover, in C, when conversion of a string to a floating-point type falls
+outside the representable range, strtof, strtod 
+and
+strtold return ąHUGE_VALF,
+ąHUGE_VAL and ąHUGE_VALL, respectively.
+On the other hand, the result of num_get conversion of such
+out-of-range floating-point values results in the most positive/negative
+representable value.
+Although many C library implementations do implement HUGE_VAL
+(etc.) as the highest representable (which is, usually, the infinity), 
+this
+isn't required by the C standard. The C library specification makes no
+statement regarding the value of HUGE_VAL and friends, which
+potentially raises the same compatibility issue as in the above case of
+unsigned integers.
+In addition, neither C nor C++ define symbolic constants for the maximum
+representable floating-point values (they only do so only for the maximum
+representable finite floating-point values), which raises a 
+usability
+issue (it would be hard for the programmer to check the result of
+num_get against overflow).
 
    
 
    
-Move to Open.
+As such, we propose to adjust the specification of num_get to
+closely follow the behavior of all of its underlying C functions.
 
    
-
    
 
-
    [
-2009-05-31 Peter adds:
-]
    
 
+
    Proposed resolution:
    
 
-
    
 
    
-I am opposed to the proposed resolution and to the premise of the issue
-in general. The traits's default definitions should NOT derive from
-integral_constant, because this is harmful, as it misleads people into
-thinking that is_bind_expression<E> always derives from
-integral_constant, whereas it may not.
+Change 22.4.2.1.2 [facet.num.get.virtuals] as follows:
 
    
+
    
 
    
-is_bind_expression and is_placeholder allow user
-specializations, and in fact, this is their primary purpose. Such user
-specializations may not derive from integral_constant, and the
-places where is_bind_expression and is_placeholder are
-used intentionally do not require such derivation.
+Stage 3:
+The sequence of chars accumulated in stage 2 (the field) is
+converted to a numeric value by the rules of one of the functions declared in
+the header <cstdlib>:
 
    
+
      
+
    • For a signed integer value, the function strtoll.
      • 
+
    • For an unsigned integer value, the function strtoull.
      • 
+
    • For a float value, the function
+    strtof.
      • 
+
    • For a double value, the function
+    strtod.
      • 
+
    • For a floating-point long double
+    value, the function strtold.
      • 
+
    
 
    
-The long-term approach here is to switch to
-BindExpression<E> and Placeholder<P>
-explicit concepts, of course, but until that happens, I say leave them
-alone.
-
    
-
    
-
-
-
-
    Proposed resolution:
    
-
      
-
    1. 
-
      
-In 20.7.12.1.1 [func.bind.isbind] change as indicated:
-
      
-
      namespace std {
- template<class T> struct is_bind_expression : integral_constant<bool, see below> { };{
-   static const bool value = see below;
- };
-}
-
      
-
      2. 
-
    2. 
-
      
-In 20.7.12.1.1 [func.bind.isbind]/2 change as indicated:
-
      
-
      static const bool value;
-
      
-
      
--2- true if T is a type returned from bind, false otherwise.
-  If T is a type returned from bind, is_bind_expression<T> shall
-be publicly derived from
-        integral_constant<bool, true>, otherwise it shall be
-publicly derived from
-          integral_constant<bool, false>.
-
      
-
      
-
      3. 
-
    3. 
-
      
-In 20.7.12.1.2 [func.bind.isplace] change as indicated:
-
      
-
      namespace std {
- template<class T> struct is_placeholder : integral_constant<int, see below> { };{
-   static const int value = see below;
- };
-}
-
      
-
      4. 
-
    4. 
-
      
-In 20.7.12.1.2 [func.bind.isplace]/2 change as indicated:
-
      
-
      static const int value;
-
      
-
      
--2- value is J if T is the type of std::placeholders::_J, 0 otherwise.
-  If T is the type of std::placeholders::_J, is_placeholder<T>
-shall be publicly
-          derived from integral_constant<int, J> otherwise it shall
-be publicly derived
-          from integral_constant<int, 0>.
-
      
-
      
-
      5. 
-
    
-
-
-
-
-
-
    
-
    1075. Response to US 65, US 74.1
    
-
    Section: 20 [utilities], 23 [containers] Status: Open
- Submitter: Alan Talbot Opened: 2009-03-20  Last modified: 2009-06-10
    
-
    View all other issues in [utilities].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    Addresses US 65 and US 74.1
    
-
-
    US 65:
    
-
-
    
-Scoped allocators and allocator propagation traits add a small amount of
-utility at the cost of a great deal of machinery. The machinery is user
-visible, and it extends to library components that don't have any
-obvious connection to allocators, including basic concepts and simple
-components like pair and tuple.
-
-
    Suggested resolution:
    
-
-
    
-Sketch of proposed resolution: Eliminate scoped allocators, replace
-allocator propagation traits with a simple uniform rule (e.g. always
-propagate on copy and move), remove all mention of allocators from
-components that don't explicitly allocate memory (e.g. pair), and adjust
-container interfaces to reflect this simplification.
-
    
-
    
-Components that I propose eliminating include HasAllocatorType,
-is_scoped_allocator, allocator_propagation_map, scoped_allocator_adaptor,
-and ConstructibleAsElement.
-
    
-
    
-
-
    US 74.1:
    
-
-
    
-
    
-Scoped allocators represent a poor trade-off for standardization, since
-(1) scoped-allocator--aware containers can be implemented outside the
-C++ standard library but used with its algorithms, (2) scoped
-allocators only benefit a tiny proportion of the C++ community
-(since few C++ programmers even use today's allocators), and (3) all C++
-users, especially the vast majority of the C++ community that won't ever
-use scoped allocators are forced to cope with the interface complexity
-introduced by scoped allocators.
-
    
-
    
-In essence, the larger community will suffer to support a very small
-subset of the community who can already implement their own
-data structures outside of the standard library. Therefore, scoped
-allocators should be removed from the working paper.
-
    
-
    
-Some evidence of the complexity introduced by scoped allocators:
-
    
-
    
-
    
-20.3.3 [pairs], 20.5 [tuple]: Large increase in the
-number of pair and tuple constructors.
-
    
-
    
-23 [containers]: Confusing "AllocatableElement" requirements throughout.
-
    
-
    
-
    Suggested resolution:
    
-
-
    
-Remove support for scoped allocators from the working paper. This
-includes at least the following changes:
-
    
-
-
    
-
    
-Remove 20.8.3 [allocator.element.concepts]
-
    
-
    
-Remove 20.8.5 [allocator.adaptor]
-
    
-
    
-Remove  [construct.element]
-
    
-
    
-In Clause 23 [containers]: replace requirements naming the
-AllocatableElement concept with requirements naming CopyConstructible,
-MoveConstructible, DefaultConstructible, or Constructible, as
-appropriate.
-
    
-
    
-
-
    
-
-
    [
-Post Summit Alan moved from NAD to Open.
-]
    
-
-
-
    [
-2009-05-15 Ganesh adds:
-]
    
-
-
-
    
-
    
-The requirement AllocatableElement should not be replaced with
-Constructible on the emplace_xxx() functions as suggested. In the
-one-parameter case the Constructible requirement is not satisfied when
-the constructor is explicit (as per 14.10.2.1 [concept.map.fct], twelfth
-bullet) but we do want to allow explicit constructors in emplace, as the
-following example shows:
-
    
-
-
    vector<shared_ptr<int>> v;
-v.emplace_back(new int); // should be allowed
-
    
-
-
    
-If the issue is accepted and scoped allocators are removed, I suggest to
-add a new pair of concepts to 20.2.7 [concept.construct], namely:
-
    
-
-
    auto concept HasExplicitConstructor<typename T, typename... Args> {
- explicit T::T(Args...);
-}
-
-auto concept ExplicitConstructible<typename T, typename... Args>
- : HasExplicitConstructor<T, Args...>, NothrowDestructible<T>
-{ }
-
    
-
-
    
-We should then use ExplicitConstructible as the requirement for all
-emplace_xxx() member functions.
-
    
-
    
-For coherence and consistency with the similar concepts
-Convertible/ExplicitlyConvertible, we might also consider changing
-Constructible to:
-
    
-
-
    auto concept Constructible<typename T, typename... Args>
- : HasConstructor<T, Args...>, ExplicitConstructible<T, Args...>
-{ }
-
    
-
-
    
-Moreover, all emplace-related concepts in 23.2.6 [container.concepts]
-should also use ExplicitConstructible instead of Constructible in the
-definitions of their axioms. In fact the concepts in 23.2.6 [container.concepts] should be
-corrected even if the issue is not accepted.
-
    
-
    
-On the other hand, if the issue is not accepted, the scoped allocator
-adaptors should be fixed because the following code:
-
    
-
-
    template <typename T> using scoped_allocator = scoped_allocator_adaptor<allocator<T>>;
-
-vector<shared_ptr<int>, scoped_allocator<shared_ptr<int>>> v;
-v.emplace_back(new int); // ops! doesn't compile
-
    
-
-
    
-doesn't compile, as the member function construct() of the scoped
-allocator requires non-explicit constructors through concept
-ConstructibleWithAllocator. Fixing that is not difficult but probably
-more work than it's worth and is therefore, IMHO, one more reason in
-support of the complete removal of scoped allocators.
-
    
-
    
-
-
    [
-2009-06-09 Alan adds:
-]
    
-
-
-
    
-
    
-I reopened this issue because I did not think that these National Body
-comments were adequately addressed by marking them NAD. My understanding
-is that something can be marked NAD if it is clearly a misunderstanding
-or trivial, but a substantive issue that has any technical merit
-requires a disposition that addresses the concerns.
-
    
-
    
-The notes in the NB comment list (US 65 & US 74.1) say that:
-
    
-
      
-
    1. 
-this issue has not introduced any new arguments not previously discussed,
-
      2. 
-
    2. 
-the vote (4-9-3) was not a consensus for removing scoped allocators,
-
      3. 
-
    3. 
-the issue is resolved by
-N2840.
-
      4. 
-
    
-
    
-My opinion is:
-
    
-
      
-
    1. 
-there are new arguments in both comments regarding concepts (which were
-not present in the library when the scoped allocator proposal was voted
-in),
-
      2. 
-
    2. 
-the vote was clearly not a consensus for removal, but just saying there
-was a vote does not provide a rationale,
-
      3. 
-
    3. 
-I do not believe that N2840 addresses these comments (although it does
-many other things and was voted in with strong approval).
-
      4. 
-
    
-
-
    
-My motivation to open the issue was to ensure that the NB comments were
-adequately addressed in a way that would not risk a "no" vote on our
-FCD. If there are responses to the technical concerns raised, then
-perhaps they should be recorded. If the members of the NB who authored
-the comments are satisfied with N2840 and the other disposition remarks
-in the comment list, then I am sure they will say so. In either case,
-this issue can be closed very quickly in Frankfurt, and hopefully will
-have helped make us more confident of approval with little effort. If in
-fact there is controversy, my thought is that it is better to know now
-rather than later so there is more time to deal with it.
-
    
-
    
-
-
-
-
    Proposed resolution:
    
-
-
-
-
-
-
    
-
    1076. unary/binary_negate need constraining and move support
    
-
    Section: 20.7.11 [negators] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-20  Last modified: 2009-05-23
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-The class templates unary/binary_negate need constraining and move support.
-
    
-
    
-Ideally these classes would be deprecated, allowing unary/binary_function to
-also be deprecated.  However, until a generic negate adaptor is introduced
-that can negate any Callable type, they must be supported so should be
-constrained.  Likewise, they should be movable, and support adopting a
-move-only predicate type.
-
    
-
    
-In order to preserve ABI compatibility, new rvalue overloads are supplied in
-preference to changing the existing pass-by-const-ref to pass-by-value.
-
    
-
    
-Do not consider the issue of forwarding mutable lvalues at this point,
-although remain open to another issue on the topic.
-
    
-
-
    [
-2009-05-01 Daniel adds:
-]
    
-
-
    
-
    
-IMO the currently proposed resolution needs some updates
-because it is ill-formed at several places:
-
    
-
-
      
-
    1. 
-
      
-In concept AdaptableUnaryFunction change
-
      
-
      typename X::result_type;
-typename X::argument_type;
-
      
-
      
-to
-
      
-
      Returnable result_type = typename X::result_type;
-typename argument_type = typename X::argument_type;
-
      
-
      
-[The replacement "Returnable result_type" instead of "typename
-result_type" is non-editorial, but maybe you prefer that as well]
-
      
-
      2. 
-
    2. 
-
      
-In concept AdaptableBinaryFunction change
-
      
-
      typename X::result_type;
-typename X::first_argument_type;
-typename X::second_argument_type;
-
      
-
      
-to
-
      
-
      Returnable result_type = typename X::result_type;
-typename first_argument_type = typename X::first_argument_type;
-typename second_argument_type = typename X::second_argument_type;
-
      
-
      
-[The replacement "Returnable result_type" instead of "typename
-result_type" is non-editorial, but maybe you prefer that as well.]
-
      
-
      3. 
-
-
    3. 
-
      
-In class unary/binary_function
-
      
-
        
-
      1. 
-I suggest to change "ReturnType" to "Returnable" in both cases.
-
        2. 
-
      2. 
-I think you want to replace the remaining occurrences of "Predicate" by "P"
-(in both classes in copy/move from a predicate)
-
        3. 
-
      
-
      4. 
-
    4. 
-
      
-I think you need to change the proposed signatures of not1 and not2, because
-they would still remain unconstrained: To make them constrained at least a
-single requirement needs to be added to enable requirement implication. This
-could be done via a dummy ("requires True<true>") or just explicit as follows:
-
      
-
        
-
      1. 
-
        template <AdaptableUnaryFunction P>
-requires Predicate< P, P::argument_type>
-unary_negate<P> not1(const P&& pred);
-template <AdaptableUnaryFunction P>
-requires Predicate< P, P::argument_type >
-unary_negate<P> not1(P&& pred);
-
        
-
        
--3- Returns: unary_negate<P>(pred).
-
        
-
        
-
        
-[Don't we want a move call for the second overload as in
-
        
-
        unary_negate<P>(std::move(pred))
-
        
-
        
-in the Returns clause ?]
-
        
-
        2. 
-
      2. 
-
        template <AdaptableBinaryFunction P>
-requires Predicate< P, P::first_argument_type, P::second_argument_type >
-binary_negate<P> not2(const P& pred);
-template <AdaptableBinaryFunction P>
-requires Predicate< P, P::first_argument_type, P::second_argument_type >
-binary_negate<P> not2(P&& pred);
-
        
-
        
--5- Returns: binary_negate<P>(pred).
-
        
-
        
-[Don't we want a move call for the second overload as in
-
        
-
        binary_negate<P>(std::move(pred))
-
        
-
        
-in the Returns clause ?]
-
        
-
        3. 
-
      
-
      5. 
-
    
-
    
-
-
    [
-Batavia (2009-05):
-]
    
-
-
    
-
    
-There is concern that complicating the solution
-to preserve the ABI seems unnecessary,
-since we're not in general preserving the ABI.
-
    
-
    
-We would prefer a separate paper consolidating all Clause 20
-issues that are for the purpose of providing constrained versions
-of the existing facilities.
+The numeric value to be stored can be one of:
 
    
+
      
+
    • zero, if the conversion function fails to convert the entire field.
+    ios_base::failbit is assigned to err.
      • 
+
    • the most positive (or negative) representable value, if
+    the field to be converted to a signed integer type represents a
+    value too large positive (or negative) to be represented in
+    val.
+    ios_base::failbit is assigned to err.
      • 
+
    • the most negative representable value or zero for an unsigned integer
+    type, if the field represents a value too large negative to be represented
+    in val.
+    ios_base::failbit is assigned to err.
      • 
+
    • the most positive representable value, if the field to be converted to
+    an unsigned integer type represents a value that cannot be represented in
+    val.
      • 
+
    • the converted value, otherwise.
      • 
+
    
 
    
-Move to Open.
+The resultant numeric value is stored in val.
+If the conversion function fails to convert the entire field, or if the
+field represents a value outside the range of representable values,
+ios_base::failbit is assigned to err.
 
    
 
    
 
 
-
    Proposed resolution:
    
-
    
-Add new concepts where appropriate::
-
    
-
-
    auto concept AdaptableUnaryFunction< typename X > {
-  typename X::result_type;
-  typename X::argument_type;
-}
-
-auto concept AdaptableBinaryFunction< typename X > {
-  typename X::result_type;
-  typename X::first_argument_type;
-  typename X::second_argument_type;
-}
-
    
-
-
    
-Revise as follows:
-
    
-
-
    
-Base 20.7.3 [base] (Only change is constrained Result)
-
    
-
-
    
-
    
--1-  The following classes are provided to simplify the typedefs of the
-argument and result types:
-
    
-
    namespace std {
-  template <class Arg, class ReturnType Result>
-  struct unary_function {
-     typedef Arg    argument_type;
-     typedef Result result_type;
-  };
-
-  template <class Arg1, class Arg2, class ReturnType Result>
-  struct binary_function {
-     typedef Arg1   first_argument_type;
-     typedef Arg2   second_argument_type;
-     typedef Result result_type;
-  };
-}
-
    
-
-
    
-Negators 20.7.11 [negators]:
-
    
-
-
    
-
    
--1- Negators not1 and not2 take a unary and a binary predicate,
-respectively, and return their complements (5.3.1).
-
    
-
-
    template <class AdaptableUnaryFunction Predicate>
-  requires Predicate< P, P::argument_type >
-  class unary_negate
-    : public unary_function<typename Predicate::argument_type,bool> {
-  public:
-    unary_negate(const unary_negate & ) = default;
-    unary_negate(unary_negate && );
-
-    requires CopyConstructible< P >
-       explicit unary_negate(const Predicate& pred); 
-    requires MoveConstructible< P >
-       explicit unary_negate(Predicate && pred);
 
-    bool operator()(const typename Predicate::argument_type& x) const;
-  };
-
    
-
    
--2 operator() returns !pred(x).
-
    
 
-
    template <class Predicate>
-  unary_negate<Predicate> not1(const Predicate&amp; pred);
-template <class Predicate>
-  unary_negate<Predicate> not1(Predicate&& pred);
-
    
-
    
--3-  Returns: unary_negate<Predicate>(pred).
-
    
 
-
    template <class AdaptableBinaryFunction Predicate >
-  requires Predicate< P, P::first_argument_type, P::second_argument_type >
-  class binary_negate
-    : public binary_function<typename Predicate::first_argument_type,
-                              typename Predicate::second_argument_type, bool> {
-  public:
-    biary_negate(const binary_negate & ) = default;
-    binary_negate(binary_negate && );
 
-    requires CopyConstructible< P >
-       explicit binary_negate(const Predicate& pred);
-    requires MoveConstructible< P >
-       explicit binary_negate(const Predicate& pred);
+
    
+
    1170. String char-like types no longer PODs
    
+
    Section: 21.1 [strings.general] Status: New
+ Submitter: Beman Dawes Opened: 2009-06-22  Last modified: 2009-11-04
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
-    bool operator()(const typename Predicate::first_argument_type& x,
-                    const typename Predicate::second_argument_type& y) const;
-  };
-
    
+
    Addresses UK 218
    
+
+
    Prior to the introduction of constant expressions into the library, 
+basic_string elements had to be POD types, and thus had to be both trivially 
+copyable and standard-layout. This ensured that they could be memcpy'ed and 
+would be compatible with other libraries and languages, particularly the C 
+language and its library.
    
+
    
+N2349,
+Constant Expressions in the Standard Library Revision 2, changed the 
+requirement in 21/1 from "POD type" to "literal type". That change had the 
+effect of removing the trivially copyable and standard-layout requirements from 
+basic_string elements.
    
+
    This means that basic_string elements no longer are guaranteed to be 
+memcpy'able, and are no longer guaranteed to be standard-layout types:
    
 
    
--4- operator() returns !pred(x,y).
+  
    3.9/p2 and 3.9/p3 both make it clear that a "trivially copyable type" is 
+  required for memcpy to be guaranteed to work.
    
+  
    Literal types (3.9p12) may have a non-trivial copy assignment operator, and 
+  that violates the trivially copyable requirements given in 9/p 6, bullet item 
+  2. 
    
+  
    Literal types (3.9p12) have no standard-layout requirement, either.
    
 
    
+
    This situation probably arose because the wording for "Constant Expressions 
+in the Standard Library" was in process at the same time the C++ POD 
+deconstruction wording was in process. 
    
+
    Since trivially copyable types meet the C++0x requirements for literal types, 
+and thus work with constant expressions, it seems an easy fix to revert the 
+basic_string element wording to its original state.
    
 
-
    template <class Predicate>
-  binary_negate<Predicate> not2(const Predicate& pred);
-template <class Predicate>
-  binary_negate<Predicate> not2(Predicate&& pred);
-
    
+ 
    [
+ 2009-07-28 Alisdair adds:
+ ]
    
 
+ 
 
    
--5- Returns: binary_negate<Predicate>(pred).
-
    
+When looking for any resolution for this issue, consider the definition of
+"character container type" in 17.3.4 [defns.character.container].  This
+does require the character type to be a POD, and this term is used in a
+number of places through clause 21 and 28. This suggests the PODness
+constraint remains, but is much more subtle than before.  Meanwhile, I
+suspect the change from POD type to literal type was intentional with
+the assumption that trivially copyable types with
+non-trivial-but-constexpr constructors should serve as well.  I don't
+believe the current wording offers the right guarantees for either of
+the above designs.
 
    
 
+
    [
+2009-11-04 Howard modifies proposed wording to disallow array types as
+char-like types.
+]
    
 
 
 
 
-
-
    
-
    1079. UK-265: RandomAccessIterator's operator- has nonsensical effects clause
    
-
    Section: 24.2.6 [random.access.iterators] Status: Open
- Submitter: Doug Gregor Opened: 2009-03-20  Last modified: 2009-03-22
    
-
    View other active issues in [random.access.iterators].
    
-
    View all other issues in [random.access.iterators].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    Addresses UK 265
    
-
-
    UK-265:
    
-
    
-This effects clause is nonesense. It looks more like an axiom stating
-equivalence, and certainly an effects clause cannot change the state of
-two arguments passed by const reference
-
    
-
-
-
 
    Proposed resolution:
    
 
-
    Modify 24.2.6 [random.access.iterators]p7-9 as follows:
    
-
-
    difference_type operator-(const X& a, const X& b);
-
    
-
      
-  
    1. Precondition: there exists a value n of
-  difference_type such that a == b + n.
      2. 
-  
    2. Effects: b == a + (b - a)
      3. 
-  
    3. Returns: (a < b) ? distance(a,b) :
-  -distance(b,a)n
      4. 
-
    
+
    Change General 21.1 [strings.general] as indicated:
    
+
    
+
    This Clause describes components for manipulating sequences of any
+literal non-array POD (3.9) type. In this Clause
+such types are called char-like types, and objects of char-like
+types are called char-like objects or simply
+characters.
    
 
    
 
 
 
 
 
+
 
    
-
    1088. Response to UK 342
    
-
    Section: 30.6.4 [futures.promise] Status: Open
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-03-22
    
-
    View other active issues in [futures.promise].
    
-
    View all other issues in [futures.promise].
    
+
    1171. duration types should be literal
    
+
    Section: 20.9.3 [time.duration] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-07-06  Last modified: 2009-10-31
    
+
    View other active issues in [time.duration].
    
+
    View all other issues in [time.duration].
    
 
    View all issues with Open status.
    
 
    Discussion:
    
-
    Addresses UK 342
    
-
-
    
-std::promise is missing a non-member overload of swap. This is
-inconsistent with other types that provide a swap member function.
-
    
-
 
    
-Add a non-member overload void swap(promise&& x,promise&& y){ x.swap(y); }
+The duration types in 20.9.3 [time.duration] are exactly the sort of type
+that should be "literal types" in the new standard.  Likewise,
+arithmetic operations on durations should be declared constexpr.
 
    
 
 
    [
-Summit:
+2009-09-21 Daniel adds:
 ]
    
 
+
 
    
-Create an issue. Move to review, attention: Howard. Detlef will also
-look into it.
+An alternative (and possibly preferable solution for potentially
+heap-allocating big_int representation types) would be to ask the core
+language to allow references to const literal types as feasible
+arguments for constexpr functions.
 
    
 
 
    [
-Post Summit Daniel provided wording.
+2009-10-30 Alisdair adds:
 ]
    
 
 
-
-
    Proposed resolution:
    
-
      
-
    1. 
+
      
 
      
-In 30.6.4 [futures.promise], before p.1, immediately after class template
-promise add:
+I suggest this issue moves from New to Open.
 
      
-
      
-template <class R>
-void swap(promise<R>& x, promise<R>& y);
-
-
      
-
      2. 
-
    2. 
+
 
      
-Change 30.6.4 [futures.promise]/10 as indicated (to fix a circular definition):
+Half of this issue was dealt with in paper
+n2994
+on constexpr constructors.
 
      
-
      
+
 
      
--10- Effects: swap(*this, other)Swaps the associated state
-of *this and other
+The other half (duration arithmetic) is on hold pending Core support for
+const & in constexpr functions.
 
      
+
+
      
+
+
+
+
      Proposed resolution:
      
 
      
-Throws: Nothing.
+Add constexpr to declaration of following functions and constructors:
 
      
-
    
-
-
  • 
 
    
-After the last paragraph in 30.6.4 [futures.promise] add the following
-prototype description:
+p1 20.9 [time]
 
    
-
    
-template <class R>
-void swap(promise<R>& x, promise<R>& y);
-
    
+
 
    
 
    
-Effects: x.swap(y)
+Header <chrono> synopsis
 
    
+
+
    [Draughting note - observe switch to pass-by-value to support constexpr]
    
+
+
+
    // duration arithmetic
+template <class Rep1, class Period1, class Rep2, class Period2>
+   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
+   constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
+   constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period, class Rep2>
+   duration<typename common_type<Rep1, Rep2>::type, Period>
+   constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
+template <class Rep1, class Period, class Rep2>
+   duration<typename common_type<Rep1, Rep2>::type, Period>
+   constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
+template <class Rep1, class Period, class Rep2>
+   duration<typename common_type<Rep1, Rep2>::type, Period>
+   constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   typename common_type<Rep1, Rep2>::type
+   constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+// duration comparisons
+template <class Rep1, class Period1, class Rep2, class Period2>
+   constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   constexpr bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   constexpr bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+template <class Rep1, class Period1, class Rep2, class Period2>
+   constexpr bool operator>=(const  duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
+// duration_cast
+template <class ToDuration, class Rep, class Period>
+   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
+
    
+
 
    
-Throws: Nothing.
+20.9.3 [time.duration]
 
    
-
    
-
    
-
    • 
 
-
+
    template <class Rep, class Period = ratio<1>>
+class duration {
+  ....
+public:
+  // 20.9.3.1, construct/copy/destroy:
+ constexpr duration() = default;
+
+ template <class Rep2>
+   constexpr explicit duration(const Rep2& r);
+ template <class Rep2, class Period2>
+   constexpr duration(const duration<Rep2, Period2>& d);
+
+  constexpr duration(const duration&) = default;
+
+  // 20.9.3.2, observer:
+  constexpr rep count() const;
+
+  // 20.9.3.3, arithmetic:
+  constexpr duration operator+() const;
+  constexpr duration operator-() const;
+  ...
+
+};
+
    
+
    
+
    [
+Note - this edit already seems assumed by definition of the duration static members zero/min/max.
+They cannot meaningfully be constexpr without this change.
+]
    
 
 
 
@@ -25682,419 +21021,319 @@ void swap(promise<R>& x, promise<R>& y);
 
 
 
    
-
    1089. Response to JP 76
    
-
    Section: 30 [thread] Status: Open
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-08-02
    
-
    View all other issues in [thread].
    
+
    1173. "Equivalence" wishy-washiness
    
+
    Section: 17 [library] Status: Open
+ Submitter: David Abrahams Opened: 2009-07-14  Last modified: 2009-10-20
    
+
    View other active issues in [library].
    
+
    View all other issues in [library].
    
 
    View all issues with Open status.
    
-
    Discussion:
    
-
    Addresses JP 76
    
-
+
    Discussion:
    
 
    
-A description for "Throws: Nothing." are not unified.
+Issue: The CopyConstructible requirements are wishy-washy.  It requires
+that the copy is "equivalent" to the original, but "equivalent" is never
+defined.
 
    
-
 
    
-At the part without throw, "Throws: Nothing." should be described.
+I believe this to be an example of a more general lack of rigor around
+copy and assignment, although I haven't done the research to dig up all
+the instances.
 
    
-
 
    
-Add "Throws: Nothing." to the following.
+It's a problem because if you don't know what CopyConstructible means,
+you also don't know what it means to copy a pair of CopyConstructible
+types.  It doesn't prevent us from writing code, but it is a hole in our
+ability to understand the meaning of copy.
+
    
+
    
+Furthermore, I'm pretty sure that vector's copy constructor doesn't
+require the elements to be EqualityComparable, so that table is actually
+referring to some ill-defined notion of equivalence when it uses ==.
 
    
-
-
      
-
    • 
-30.3.1.6 [thread.thread.static] p1
-
      • 
-
    • 
-30.4.3.1 [thread.lock.guard] p4
-
      • 
-
    • 
-30.4.3.2.1 [thread.lock.unique.cons] p6
-
      • 
-
    • 
-30.5.1 [thread.condition.condvar] p7 and p8
-
      • 
-
    • 
-30.5.2 [thread.condition.condvarany] p6, p7, p19, p21 and p25
-
      • 
-
    
 
 
    [
-Summit:
+2009 Santa Cruz:
 ]
    
 
+
 
    
-Pass on to editor.
+Move to "Open". Dave is right that this is a big issue. Paper D2987
+("Defining Move Special Member Functions", Bjarne Stroustrup and
+Lawrence Crowl) touches on this but does not solve it. This issue is
+discussed in Elements of Programming.
 
    
 
-
    [
-Post Summit:  Editor declares this non-editorial.
-]
    
 
 
-
    [
-2009-08-01 Howard provided wording:
-]
    
+
    Proposed resolution:
    
+
+
 
 
-
    
 
+
    
+
    1175. unordered complexity
    
+
    Section: 23.2.5 [unord.req] Status: New
+ Submitter: Pablo Halpern Opened: 2009-07-17  Last modified: 2009-07-19
    
+
    View other active issues in [unord.req].
    
+
    View all other issues in [unord.req].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-The definition of "Throws: Nothing." that I added is probably going to
-be controversial, but I beg you to consider it seriously.
+When I look at the unordered_* constructors, I think the complexity is poorly
+described and does not follow the style of the rest of the standard.
 
    
 
-
    
 
    
-In C++ there are three "flow control" options for a function:
+The complexity for the default constructor is specified as constant.
+ Actually, it is proportional to n, but there are no invocations of
+value_type constructors or other value_type operations.
 
    
 
-
      
-
    1. 
-It can return, either with a value, or with void.
-
      2. 
-
    2. 
-It can call a function which never returns, such as std::exit or
-std::terminate.
-
      3. 
-
    3. 
-It can throw an exception.
-
      4. 
-
    
-
-The above list can be abbreviated with:
-
-
      
-
    1. Returns.
      2. 
-
    2. Ends program.
      3. 
-
    3. Throws exception.
      4. 
-
    
-
 
    
-In general a function can have the behavior of any of these 3, or any combination
-of any of these three, depending upon run time data.
+For the iterator-based constructor the complexity should be:
 
    
 
-
      
-
    1. R
      2. 
-
    2. E
      3. 
-
    3. T
      4. 
-
    4. RE
      5. 
-
    5. RT
      6. 
-
    6. ET
      7. 
-
    7. RET
      8. 
-
    
+
    
+Complexity: exactly n calls to construct value_type
+from InputIterator::value_type (where n = distance(f,l)).
+The number of calls to key_equal::operator() is proportional to
+n in the average case and n*n in the worst case.
+
    
 
-
    
-A function with no throw spec, and no documentation, is in general a RET
-function.  It may return, it may end the program, or it may throw.  When we
-specify a function with an empty throw spec:
-
    
 
-
    void f() throw();
-
    
 
+
    Proposed resolution:
    
 
    
-We are saying that f() is an RE function:  It may return or end
-the program, but it will not throw.
 
    
 
-
    
-I posit that there are very few places in the library half of the standard
-where we intend for functions to be able to end the program (call terminate).
-And none of those places where we do say terminate could be called,
-do we currently say "Throws: Nothing.".
-
    
 
-
    
-I believe that if we define "Throws: Nothing." to mean R,
-we will both clarify many, many places in the standard, and give us a
-good rationale for choosing between "Throws: Nothing." (R)
-and throw() (RE) in the future.  Indeed, this may give us motivation
-to change several throw()s to "Throws: Nothing.".
-
    
-
    
 
-
    
-I did not add the following changes as JP 76 requested as I believe we want to
-allow these functions to throw:
-
    
 
-
    
+
+
    
+
    1176. Make thread constructor non-variadic
    
+
    Section: 30.3.1.2 [thread.thread.constr] Status: New
+ Submitter: Howard Hinnant Opened: 2009-07-18  Last modified: 2009-07-18
    
+
    View other active issues in [thread.thread.constr].
    
+
    View all other issues in [thread.thread.constr].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Add a paragraph under 30.4.3.1 [thread.lock.guard] p4:
+The variadic thread constructor is causing controversy, e.g.
+N2901.
+This issue has been created as a placeholder for this course of action.
 
    
 
-
    explicit lock_guard(mutex_type& m);
-
    
-
-
    
-Throws: Nothing.
-
    
-
    
+
    template <class F, class ...Args> thread(F&& f, Args&&... args);
+
    
 
 
    
-Add a paragraph under 30.4.3.2.1 [thread.lock.unique.cons] p6:
+See 929 for wording which specifies an rvalue-ref signature but
+with "decay behavior", but using variadics.
 
    
 
-
    explicit unique_lock(mutex_type& m);
-
    
-
-
    
-Throws: Nothing.
-
    
-
    
 
+
    Proposed resolution:
    
 
    
-Add a paragraph under 30.5.2 [thread.condition.condvarany] p19, p21 and p25:
 
    
 
-
    template <class Lock, class Rep, class Period> 
-  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
-
    
 
-
    
-Throws: Nothing.
-
    
-
    
 
-
    template <class Lock, class Duration, class Predicate> 
-  bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& rel_time, Predicate pred);
-
    
 
-
    
-Throws: Nothing.
-
    
-
    
 
-
    template <class Lock, class Rep, class Period, class Predicate> 
-  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
-
    
+
    
+
    1177. Improve "diagnostic required" wording
    
+
    Section: 20.9.3 [time.duration] Status: Ready
+ Submitter: Howard Hinnant Opened: 2009-07-18  Last modified: 2009-10-26
    
+
    View other active issues in [time.duration].
    
+
    View all other issues in [time.duration].
    
+
    View all issues with Ready status.
    
+
    Discussion:
    
+
    
+"diagnostic required" has been used (by me) for code words meaning "use
+enable_if to constrain templated functions.  This needs to be
+improved by referring to the function signature as not participating in
+the overload set, and moving this wording to a Remarks paragraph.
+
    
 
-
    
-Throws: Nothing.
-
    
-
    
+
    [
+2009-10 Santa Cruz:
+]
    
 
-
    
 
+
    
+Moved to Ready.
 
    
 
 
 
-
-
 
    Proposed resolution:
    
-
    
-Add a paragraph after 17.5.1.4 [structure.specifications] p4:
-
    
-
-
    
-
    
--3- Descriptions of function semantics contain the following elements
-(as appropriate):158
-
    
-
      
-
    • ...
      • 
-
    • 
-Throws: any exceptions thrown by the function, and the conditions
-that would cause the exception
-
      • 
-
    • ...
      • 
-
    
-
-
    
--4- For non-reserved replacement and handler functions, ...
-
    
+
    [
+This proposed resolution addresses 947 and 974. 
+]
    
 
-
    
-A "Throws: Nothing." element indicates that the function shall
-return ordinarily, and not via an exception.  This element also
-indicates that the function shall return. [Note: This
-differs from an empty throw specification which may cause a function to
-call unexpected and subsequently terminate. —
-end note]
-
    
-
    
 
+
      
+
    1. 
 
      
-Add a paragraph under 30.3.1.6 [thread.thread.static] p1:
+Change 20.9.3.1 [time.duration.cons]:
 
      
 
-
      unsigned hardware_concurrency();
+
      
+
      template <class Rep2> 
+  explicit duration(const Rep2& r);
 
      
-
+
      
+
      
+Requires: Remarks:
+Rep2 shall be implicitly convertible to rep and
+
      
+
        
+
      • 
+treat_as_floating_point<rep>::value shall be true or
+
        • 
+
      • 
+treat_as_floating_point<Rep2>::value shall be false.
+
        • 
+
      
 
      
--1- Returns: ...
+Diagnostic required If these constraints are not met, this
+constructor shall not participate in overload resolution. [Example:
 
      
-
-
      
-Throws: Nothing.
-
      
-
      
+
      duration<int, milli> d(3); // OK 
+duration<int, milli> d(3.5); // error 
+
      
 
 
      
-Add a paragraph under 30.5.1 [thread.condition.condvar] p7 and p8:
+— end example]
 
      
 
-
      
 
      
-[Informational, not to be incluced in the WP: The POSIX spec allows only:
+Effects: Constructs an object of type duration.
 
      
-
      
-
      [EINVAL]
      
-
      The value cond does not refer to an initialized condition variable. — end informational]
      
-
      
-
-
      void notify_one();
-
      
 
 
      
--7- Effects: ...
+Postcondition: count() == static_cast<rep>(r).
 
      
 
-
      
-Throws: Nothing.
-
      
 
      
 
-
      void notify_all();
+
      template <class Rep2, class Period2>
+  duration(const duration<Rep2, Period2>& d);
 
      
-
+
      
 
      
--8- Effects: ...
+Requires: Remarks: treat_as_floating_point<rep>::value shall be true or
+ratio_divide<Period2, period>::type::den shall be 1. Diagnostic
+required, else this constructor shall not participate in overload
+resolution. [Note: This requirement prevents implicit truncation error
+when converting between integral-based duration types. Such a
+construction could easily lead to confusion about the value of the
+duration. — end note] [Example:
 
      
 
-
      
-Throws: Nothing.
-
      
-
      
-
+
      duration<int, milli> ms(3); 
+duration<int, micro> us = ms; // OK 
+duration<int, milli> ms2 = us; // error 
+
      
 
 
      
-Add a paragraph under 30.5.2 [thread.condition.condvarany] p6 and p7:
+— end example]
 
      
 
-
      
-
      void notify_one();
-
      
-
 
      
--6- Effects: ...
+Effects: Constructs an object of type duration, constructing
+rep_ from
+duration_cast<duration>(d).count().
 
      
 
-
      
-Throws: Nothing.
-
      
 
      
 
-
      void notify_all();
-
      
-
-
      
--7- Effects: ...
-
      
 
-
      
-Throws: Nothing.
-
      
 
      
+
      2. 
 
-
-
-
-
-
-
-
      
-
      1090. Missing description of packaged_task member swap,  missing non-member swap
      
-
      Section: 30.6.7 [futures.task] Status: Open
- Submitter: Daniel Krügler Opened: 2009-03-22  Last modified: 2009-05-24
      
-
      View all issues with Open status.
      
-
      Discussion:
      
+
    2. 
 
      
-Class template packaged_task in 30.6.7 [futures.task] shows a member swap
-declaration, but misses to
-document it's effects (No prototype provided). Further on this class
-misses to provide a non-member
-swap.
+Change the following paragraphs in 20.9.3.5 [time.duration.nonmember]:
 
      
 
-
      [
-Batavia (2009-05):
-]
      
-
 
      
-
      
-Alisdair notes that paragraph 2 of the proposed resolution has already been
-applied in the current Working Draft.
-
      
-
      
-We note a pending future-related paper by Detlef;
-we would like to wait for this paper before proceeding.
-
      
-
      
-Move to Open.
-
      
+
      template <class Rep1, class Period, class Rep2> 
+  duration<typename common_type<Rep1, Rep2>::type, Period> 
+  operator*(const duration<Rep1, Period>& d, const Rep2& s);
+
      
+
      
+Requires Remarks: Rep2 shall be implicitly convertible to
+CR(Rep1, Rep2), else this signature shall not participate in
+overload resolution. Diagnostic required.
 
      
 
-
      [
-2009-05-24 Daniel removed part 2 of the proposed resolution.
-]
      
+
      template <class Rep1, class Period, class Rep2> 
+  duration<typename common_type<Rep1, Rep2>::type, Period> 
+  operator*(const Rep1& s, const duration<Rep2, Period>& d);
+
      
+
      
+Requires Remarks: Rep1 shall be implicitly convertible to
+CR(Rep1, Rep2), else this signature shall not participate in
+overload resolution. Diagnostic required.
+
      
 
+
      template <class Rep1, class Period, class Rep2> 
+  duration<typename common_type<Rep1, Rep2>::type, Period> 
+  operator/(const duration<Rep1, Period>& d, const Rep2& s);
+
      
+
      
+Requires Remarks: Rep2 shall be implicitly convertible to
+CR(Rep1, Rep2) and Rep2 shall not be an instantiation of
+duration, else this signature shall not participate in
+overload resolution. Diagnostic required.
+
      
 
+
      template <class Rep1, class Period, class Rep2> 
+  duration<typename common_type<Rep1, Rep2>::type, Period> 
+  operator%(const duration<Rep1, Period>& d, const Rep2& s);
+
      
+
      
+Requires Remarks: Rep2 shall be implicitly convertible to
+CR(Rep1, Rep2) and Rep2 shall not be an instantiation of
+duration, else this signature shall not participate in
+overload resolution. Diagnostic required.
+
      
 
-
      Proposed resolution:
      
-
        
-
      1. 
-
        
-In 30.6.7 [futures.task], immediately after the definition of class
-template packaged_task add:
-
        
-
        
-template<class R, class... Argtypes>
-void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&);
-
-
        
+
      
 
      3. 
-
    
 
-
      
 
    1. 
 
      
-In 30.6.7 [futures.task], immediately after operator= prototype
-description (After p. 8) add:
+Change the following paragraphs in 20.9.3.7 [time.duration.cast]:
 
      
-
      void swap(packaged_task& other);
+
+
      template <class ToDuration, class Rep, class Period> 
+  ToDuration duration_cast(const duration<Rep, Period>& d);
 
      
+
 
      
-
      
-Effects: Swaps the associated state of *this and other.
-
      
-
      
-Throws: Nothing.
-
      
+Requires Remarks: ToDuration shall be an instantiation of
+duration, else this signature shall not participate in
+overload resolution. Diagnostic required.
 
      
 
      
 
      2. 
+
 
    2. 
 
      
-At the end of 30.6.7 [futures.task] (after p. 20), add add the following
-prototype description:
+Change the following paragraphs in 20.9.4.7 [time.point.cast]:
 
      
 
-
      
-template<class R, class... Argtypes>
-void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgTypes...)>& y);
-
      
+
      template <class ToDuration, class Clock, class Duration> 
+  time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
+
      
+
 
      
-
      
-Effects: x.swap(y)
-
      
-
      
-Throws: Nothing.
-
      
+Requires Remarks: ToDuration shall be an instantiation of
+duration, else this signature shall not participate in
+overload resolution. Diagnostic required.
 
      
 
      
 
      3. 
@@ -26104,2009 +21343,2483 @@ void swap(packaged_task<R(ArgTypes...)>& x, packaged_task<R(ArgType
 
 
 
+
 
      
-
      1091. Multimap description confusing
      
-
      Section: 23.4.2.2 [multimap.modifiers] Status: Review
- Submitter: LWG Opened: 2009-03-22  Last modified: 2009-07-04
      
-
      View all issues with Review status.
      
+
      1180. Missing string_type member typedef in class sub_match
      
+
      Section: 28.9.1 [re.submatch.members] Status: New
+ Submitter: Daniel Krügler Opened: 2009-07-25  Last modified: 2009-07-26
      
+
      View all issues with New status.
      
 
      Discussion:
      
-
-
      Addresses UK 246
      
 
      
-The content of this sub-clause is purely trying to describe in words the
-effect of the requires clauses on these operations, now that we have
-Concepts. As such, the description is more confusing than the signature
-itself. The semantic for these functions is adequately covered in the
-requirements tables in 23.2.4 [associative.reqmts].
+The definition of class template sub_match is strongly dependent
+on the type basic_string<value_type>, both in interface and effects,
+but does not provide a corresponding typedef string_type, as e.g.
+class match_results does, which looks like an oversight to me that
+should be fixed.
 
      
 
-
      [
-Beman adds:
-]
      
 
+
      Proposed resolution:
      
 
-
      
-Pete is clearly right that
-this one is technical rather than editorial.
-
      
+
        
+
      1. 
+
        
+In the class template sub_match synopsis 28.9 [re.submatch]/1
+change as indicated:
+
        
 
-
        [
-Batavia (2009-05):
-]
        
+
        template <class BidirectionalIterator>
+class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator> {
+public:
+  typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
+  typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
+  typedef BidirectionalIterator iterator;
+  typedef basic_string<value_type> string_type;
 
-
        
+  bool matched;
+
+  difference_type length() const;
+  operator basic_string<value_type>string_type() const;
+  basic_string<value_type>string_type str() const;
+  int compare(const sub_match& s) const;
+  int compare(const basic_string<value_type>string_type& s) const;
+  int compare(const value_type* s) const;
+};
+
        
+
        2. 
+
+
      2. 
 
        
-We agree with the proposed resolution.
+In 28.9.1 [re.submatch.members]/2 change as indicated:
 
        
+
+
        operator basic_string<value_type>string_type() const;
+
        
+
+
        
+Returns: matched ? basic_string<value_type>
+string_type(first, second) : basic_string<value_type>
+string_type().
+
        
+
        
+
        3. 
+
+
      3. 
 
        
-Move to Review.
+In 28.9.1 [re.submatch.members]/3 change as indicated:
 
        
-
    
 
+
    basic_string<value_type>string_type str() const;
+
    
+
+
    
+Returns: matched ? basic_string<value_type>
+string_type(first, second) : basic_string<value_type>
+string_type().
+
    
+
    
+
+
 
-
    Proposed resolution:
    
-
    
-Strike 23.4.2.2 [multimap.modifiers] entirely
-(but do NOT strike these signatures from the class template definition!).
-
    
 
 
 
 
 
 
    
-
    1093. Multiple definitions for random_shuffle algorithm
    
-
    Section: 25.4.12 [alg.random.shuffle] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-03-22  Last modified: 2009-07-28
    
-
    View all other issues in [alg.random.shuffle].
    
-
    View all issues with Open status.
    
+
    1181. Invalid sub_match comparison operators
    
+
    Section: 28.9.2 [re.submatch.op] Status: New
+ Submitter: Daniel Krügler Opened: 2009-07-25  Last modified: 2009-07-28
    
+
    View all other issues in [re.submatch.op].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
 
    
-There are a couple of issues with the declaration of the random_shuffle
-algorithm accepting a random number engine.
+Several heterogeneous comparison operators of class template
+sub_match are specified by return clauses that are not valid
+in general. E.g. 28.9.2 [re.submatch.op]/7:
 
    
 
-
      
-
    1. 
-The Iterators must be shuffle iterators, yet this requirement is missing.
-
      2. 
-
    2. 
-The RandomNumberEngine concept is now provided by the random number
-library
-(n2836)
-and the placeholder should be removed.
-
      3. 
-
    
-
-
    [
-2009-05-02 Daniel adds:
-]
    
-
-
+
    template <class BiIter, class ST, class SA>
+bool operator==(
+  const basic_string<
+    typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+  const sub_match<BiIter>& rhs);
+
    
 
    
+Returns: lhs == rhs.str().
+
    
+
    
+
 
    
-this issue completes adding necessary requirement to the
-third new random_shuffle overload. The current suggestion is:
+The returns clause would be ill-formed for all cases where
+ST != std::char_traits<iterator_traits<BiIter>::value_type>
+or SA != std::allocator<iterator_traits<BiIter>::value_type>.
+
    
+
    
+The generic character of the comparison was intended, so
+there are basically two approaches to fix the problem: The
+first one would define the semantics of the comparison
+using the traits class ST (The semantic of basic_string::compare
+is defined in terms of the compare function of the corresponding
+traits class), the second one would define the semantics of the
+comparison using the traits class
 
    
 
-
    template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
-requires ShuffleIterator<Iter>
-void random_shuffle(Iter first, Iter last, Rand&& g);
+
    std::char_traits<iterator_traits<BiIter>::value_type>
 
    
 
 
    
-IMO this is still insufficient and I suggest to add the requirement
+which is essentially identical to
 
    
-
    Convertible<Rand::result_type, Iter::difference_type>
+
+
    std::char_traits<sub_match<BiIter>::value_type>
 
    
-
    
-to the list (as the two other overloads already have).
-
    
 
 
    
-Rationale:
+I suggest to follow the second approach, because
+this emphasizes the central role of the sub_match
+object as part of the comparison and would also
+make sure that a sub_match comparison using some
+basic_string<char_t, ..> always is equivalent to
+a corresponding comparison with a string literal
+because of the existence of further overloads (beginning
+from 28.9.2 [re.submatch.op]/19). If users really want to
+take advantage of their own traits::compare, they can
+simply write a corresponding compare function that
+does so.
 
    
 
-
    
-
    
-Its true that this third overload is somewhat different from the remaining
-two. Nevertheless we know from UniformRandomNumberGenerator, that
-it's result_type is an integral type and that it satisfies
-UnsignedIntegralLike<result_type>.
-
    
+
+
    Proposed resolution:
    
+
      
+
    1. 
 
      
-To realize it's designated task, the algorithm has to invoke the
-Callable aspect of g and needs to perform some algebra involving
-it's min()/max() limits to compute another index value that
-at this point is converted into Iter::difference_type. This is so,
-because 24.2.6 [random.access.iterators] uses this type as argument
-of it's algebraic operators. Alternatively consider the equivalent
-iterator algorithms in 24.4 [iterator.operations] with the same result.
+In 28.9.2 [re.submatch.op] change as indicated:
 
      
+
+
        
+
      1. 
+
 
        
-This argument leads us to the conclusion that we also need
-Convertible<Rand::result_type, Iter::difference_type> here.
+If 1180 is accepted:
 
        
-
    
 
+
    
+
    template <class BiIter, class ST, class SA>
+  bool operator==(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
+
    
+7 Returns: lhstypename
+sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) ==
+rhs.str().
 
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    template <class BiIter, class ST, class SA>
+  bool operator!=(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
 
    
-
    
-Alisdair notes that point (ii) has already been addressed.
-
    
-
    
-We agree with the proposed resolution to point (i)
-with Daniel's added requirement.
-
    
-
    
-Move to Review.
-
    
+8 Returns: lhstypename
+sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) !=
+rhs.str().
 
    
 
-
    [
-2009-06-05 Daniel updated proposed wording as recommended in Batavia.
-]
    
-
+
    template <class BiIter, class ST, class SA>
+  bool operator<(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
-
    [
-2009-07-28 Alisdair adds:
-]
    
+
    
+9 Returns: lhstypename
+sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) <
+rhs.str().
+
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator>(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
 
    
-Revert to Open, with a note there is consensus on direction but the
-wording needs updating to reflect removal of concepts.
+10 Returns: lhstypename
+sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) >
+rhs.str().
 
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator>=(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
-
    Proposed resolution:
    
-
    
-Change in 25.2 [algorithms.syn] and 25.4.12 [alg.random.shuffle]:
-
    
-
-
    concept UniformRandomNumberGenerator<typename Rand> { }
-template<RandomAccessIterator Iter, UniformRandomNumberGenerator Rand>
-  requires ShuffleIterator<Iter> &&
-  Convertible<Rand::result_type, Iter::difference_type>
-  void random_shuffle(Iter first, Iter last, Rand&& g);
-
    
+
    
+11 Returns: lhstypename
+sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) >=
+rhs.str().
+
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator<=(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
+
    
+12 Returns: lhstypename
+sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) <=
+rhs.str().
+
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator==(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
+
    
+13 Returns: lhs.str() == rhstypename
+sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
+
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator!=(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    
-
    1094. Response to JP 65 and JP 66
    
-
    Section: 27.5.4.3 [iostate.flags] Status: Review
- Submitter: P.J. Plauger Opened: 2009-03-24  Last modified: 2009-05-23
    
-
    View all other issues in [iostate.flags].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
-
    Addresses JP 65 and JP 66
    
+
    
+14 Returns: lhs.str() != rhstypename
+sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
+
    
 
-
    
-Switch from "unspecified-bool-type" to "explicit operator bool() const". 
-
    
+
    template <class BiIter, class ST, class SA>
+  bool operator<(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    
-Replace operator unspecified-bool-type() const;" with explicit operator bool() const;
-
    
+
    
+15 Returns: lhs.str() < rhstypename
+sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
+
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    template <class BiIter, class ST, class SA>
+  bool operator>(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
 
    
-We agree with the proposed resolution.
-Move to Review.
+16 Returns: lhs.str() > rhstypename
+sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
 
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator>=(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    Proposed resolution:
    
-
    
-Change the synopis in 27.5.4 [ios]:
-
    
-
-
    explicit operator unspecified-bool-type bool() const;
-
    
-
-
    
-Change 27.5.4.3 [iostate.flags]:
-
    
+
    
+17 Returns: lhs.str() >= rhstypename
+sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
+
    
 
-
    explicit operator unspecified-bool-type bool() const;
+
    template <class BiIter, class ST, class SA>
+  bool operator<=(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
    
 
 
    
-
    
--1- Returns: !fail() If fail() then a value that will evaluate
-false in a boolean context; otherwise a value that will evaluate true in
-a boolean context. The value type returned shall not be convertible to
-int.
-
    
-
    
-[Note: This conversion can be used in contexts where a bool is expected
-(e.g., an if condition); however, implicit conversions (e.g.,
-to int) that can occur with bool are not allowed,
-eliminating some sources of user error. One possible implementation
-choice for this type is pointer-to-member. -- end note]
-
    
+18 Returns: lhs.str() <= rhstypename
+sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
 
    
 
    
 
+
 
+
  • 
 
-
-
-
-
-
    
-
    1095. Shared objects and the library wording unclear
    
-
    Section: 17.6.3.10 [res.on.objects] Status: Review
- Submitter: Beman Dawes Opened: 2009-03-27  Last modified: 2009-05-23
    
-
    View all issues with Review status.
    
-
    Discussion:
    
 
    
-N2775,
-Small library thread-safety revisions, among other changes, removed a note from
-17.6.3.10 [res.on.objects] that read:
+If 1180 is not accepted:
 
    
 
 
    
-[Note: This prohibition against concurrent non-const access means that
-modifying an object of a standard library type shared between threads
-without using a locking mechanism may result in a data race. --end note.]
+
    template <class BiIter, class ST, class SA>
+  bool operator==(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
+
    
+7 Returns: lhsbasic_string<typename
+sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) ==
+rhs.str().
 
    
 
-
    
-That resulted in wording which is technically correct but can only be
-understood by reading the lengthy and complex 17.6.4.7 [res.on.data.races]
-Data race avoidance. This has the effect of making
-17.6.3.10 [res.on.objects] unclear, and has already resulted in a query
-to the LWG reflector. See c++std-lib-23194.
-
    
-
-
    [
-Batavia (2009-05):
-]
    
+
    template <class BiIter, class ST, class SA>
+  bool operator!=(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
 
    
-
    
-The proposed wording seems to need a bit of tweaking
-("really bad idea" isn't quite up to standardese).
-We would like feedback
-as to whether the original Note's removal was intentional.
-
    
-
    
-Change the phrase "is a really bad idea"
-to "risks undefined behavior" and
-move to Review status.
-
    
+8 Returns: lhsbasic_string<typename
+sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) !=
+rhs.str().
 
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator<(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
-
    Proposed resolution:
    
-
    
-Change 17.6.3.10 [res.on.objects] as indicated:
-
    
+
    
+9 Returns: lhsbasic_string<typename
+sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) <
+rhs.str().
+
    
+
+
    template <class BiIter, class ST, class SA>
+  bool operator>(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
 
    
-
    
-The behavior of a program is undefined if calls to standard library
-functions from different threads may introduce a data race. The
-conditions under which this may occur are specified in 17.6.4.7.
-
    
-
    
-[Note: Thus modifying an object of a standard library type shared between
-threads risks undefined behavior unless objects of the type are explicitly
-specified as being sharable without data races or the user supplies a
-locking mechanism. --end note]
-
    
+10 Returns: lhsbasic_string<typename
+sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) >
+rhs.str().
 
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator>=(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
+
    
+11 Returns: lhsbasic_string<typename
+sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) >=
+rhs.str().
+
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator<=(
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
+    const sub_match<BiIter>& rhs);
+
    
 
+
    
+12 Returns: lhsbasic_string<typename
+sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) <=
+rhs.str().
+
    
 
-
    
-
    1097. #define __STDCPP_THREADS
    
-
    Section: 18.2 [support.types] Status: Review
- Submitter: Jens Maurer Opened: 2009-04-03  Last modified: 2009-05-23
    
-
    View all other issues in [support.types].
    
-
    View all issues with Review status.
    
-
    Discussion:
    
-
    Addresses DE 18
    
+
    template <class BiIter, class ST, class SA>
+  bool operator==(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    
-Freestanding implementations do not (necessarily) have
-  support for multiple threads (see 1.10 [intro.multithread]).
-  Applications and libraries may want to optimize for the
-  absence of threads.  I therefore propose a preprocessor
-  macro to indicate whether multiple threads can occur.
-
    
+
    
+13 Returns: lhs.str() == rhsbasic_string<typename
+sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
+
    
 
-
    
-There is ample prior implementation experience for this
-  feature with various spellings of the macro name.  For
-  example, gcc implicitly defines _REENTRANT
-  if multi-threading support is selected on the compiler
-  command-line.
-
    
+
    template <class BiIter, class ST, class SA>
+  bool operator!=(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    
-While this is submitted as a library issue, it may be more
-  appropriate to add the macro in 16.8 cpp.predefined in the
-  core language.
-
    
+
    
+14 Returns: lhs.str() != rhsbasic_string<typename
+sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
+
    
 
-
    
-See also
-N2693.
-
    
+
    template <class BiIter, class ST, class SA>
+  bool operator<(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    
+15 Returns: lhs.str() < rhsbasic_string<typename
+sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
+
    
+
+
    template <class BiIter, class ST, class SA>
+  bool operator>(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
 
    
-
    
-We agree with the issue, and believe it is properly a library issue.
-
    
-
    
-We prefer that the macro be conditionally defined
-as part of the <thread> header.
-
    
-
    
-Move to Review.
-
    
+16 Returns: lhs.str() > rhsbasic_string<typename
+sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
 
    
 
+
    template <class BiIter, class ST, class SA>
+  bool operator>=(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
 
-
    Proposed resolution:
    
-
    
-Insert a new subsection before 18.2 [support.types], entitled
-"Feature Macros" (support.macros):
-
    
 
    
-
    
-The standard library defines the following macros; no explicit
-prior inclusion of any header file is necessary.
-
    
+17 Returns: lhs.str() >= rhsbasic_string<typename
+sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
+
    
+
+
    template <class BiIter, class ST, class SA>
+  bool operator<=(const sub_match<BiIter>& lhs,
+    const basic_string<
+      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
    
+
 
    
-
    
-
    __STDCPP_THREADS
    
-
    
-The macro __STDCPP_THREADS shall be defined if and only if a
-    program can have more than one thread of execution (1.10 [intro.multithread]).
-If the macro is defined, it shall have the same
-    value as the predefined macro __cplusplus (16.8 [cpp.predefined]).
-
    
-
    
+18 Returns: lhs.str() <= rhsbasic_string<typename
+sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
 
    
 
    
 
+
    • 
+
+
+
+
+
 
 
 
 
 
 
    
-
    1098. definition of get_pointer_safety()
    
-
    Section: 20.8.10.7 [util.dynamic.safety] Status: Open
- Submitter: Jens Maurer Opened: 2009-04-03  Last modified: 2009-05-23
    
-
    View all other issues in [util.dynamic.safety].
    
-
    View all issues with Open status.
    
+
    1182. Unfortunate hash dependencies
    
+
    Section: 20.7.16 [unord.hash] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-07-28  Last modified: 2009-09-21
    
+
    View other active issues in [unord.hash].
    
+
    View all other issues in [unord.hash].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
    Addresses DE 18
    
-
 
    
- In 20.8.10.7 [util.dynamic.safety], get_pointer_safety() purports
-to define behavior for
- non-safely derived pointers (3.7.4.3 [basic.stc.dynamic.safety]).  However,
- the cited core-language section in paragraph 4 specifies undefined behavior
- for the use of such pointer values.  This seems an unfortunate near-contradiction.
- I suggest to specify the term relaxed pointer safety in
- the core language section and refer to it from the library description.
- This issue deals with the library part, the corresponding core issue (c++std-core-13940)
- deals with the core modifications.
+The implied library dependencies created by spelling out all the hash
+template specializations in the <functional> synopsis are unfortunate. 
+The potential coupling is greatly reduced if the hash specialization is
+declared in the appropriate header for each library type, as it is much
+simpler to forward declare the primary template and provide a single
+specialization than it is to implement a hash function for a string or
+vector without providing a definition for the whole string/vector
+template in order to access the necessary bits.
 
    
 
 
    
-See also
-N2693.
+Note that the proposed resolution purely involves moving the
+declarations of a few specializations, it specifically does not make any
+changes to 20.7.16 [unord.hash].
 
    
 
 
    [
-Batavia (2009-05):
+2009-09-15 Daniel adds:
 ]
    
 
+
 
    
+
    
 
    
-We recommend if this issue is to be moved,
-the issue be moved concurrently with the cited Core issue.
-
    
-
    
-We agree with the intent of the proposed resolution.
-We would like input from garbage collection specialists.
+I suggest to add to the current existing
+proposed resolution the following items.
 
    
+
+
      
+
    • 
 
      
-Move to Open.
+Add to the very first strike-list of the currently suggested resolution
+the following lines:
 
      
-
    
-
 
+
    template <> struct hash<std::error_code>;
+template <> struct hash<std::thread::id>;
+
    
+
 
-
    Proposed resolution:
    
+
  • 
 
    
-In 20.8.10.7 [util.dynamic.safety] p16, replace the description of
-get_pointer_safety() with:
+Add the following declarations to 19.5 [syserr], header
+<system_error> synopsis after // 19.5.4:
 
    
 
-
    
-
    
-pointer_safety get_pointer_safety();
-
    
-
    
+
    
+// 19.5.x hash support
+template <class T> struct hash;
+template <> struct hash<error_code>;
+
+
    
+
    • 
+
+
  • 
 
    
-Returns: an enumeration value indicating the implementation's treatment
-of pointers that are not safely derived (3.7.4.3). Returns
-pointer_safety::relaxed if pointers that are not safely derived will be
-treated the same as pointers that are safely derived for the duration of
-the program. Returns pointer_safety::preferred if pointers that are not
-safely derived will be treated the same as pointers that are safely
-derived for the duration of the program but allows the implementation to
-hint that it could be desirable to avoid dereferencing pointers that are
-not safely derived as described. [Example: pointer_safety::preferred
-might be returned to detect if a leak detector is running to avoid
-spurious leak reports. -- end note] Returns pointer_safety::strict if
-pointers that are not safely derived might be treated differently than
-pointers that are safely derived.
+Add a new clause 19.5.X (probably after 19.5.4):
 
    
-
    
-Returns: Returns pointer_safety::strict if the implementation has
-   strict pointer safety (3.7.4.3 [basic.stc.dynamic.safety]). It is
-   implementation-defined whether get_pointer_safety returns
-   pointer_safety::relaxed or pointer_safety::preferred if the
-   implementation has relaxed pointer safety
-   (3.7.4.3 [basic.stc.dynamic.safety]).Footnote
-
    
 
+
    
 
    
-Throws: nothing
+19.5.X Hash support [syserr.hash]
 
    
 
-
    
-Footnote) pointer_safety::preferred might be returned to indicate to the
-   program that a leak detector is running so that the program can avoid
-   spurious leak reports.
-
-
    
+
    
+template <> struct hash<error_code>;
+
    
 
+
    
+An explicit specialization of the class template hash (20.7.16 [unord.hash])
+shall be provided
+for the type error_code suitable for using this type as key in
+unordered associative
+containers (23.5 [unord]).
+
    
 
    
-
    • 
-
-
-
-
+
 
-
    
-
    1099. Various issues
    
-
    Section: 17 [library] Status: Open
- Submitter: David Abrahams Opened: 2009-03-21  Last modified: 2009-05-23
    
-
    View other active issues in [library].
    
-
    View all other issues in [library].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-Notes
-
    
-
    
+
  • 
 
    
-[2009-03-21 Sat] p. 535 at the top we need MoveConstructible V1,
-MoveConstructible V2 (where V1,V2 are defined on 539).  Also make_tuple
-on 550
+Add the following declarations to 30.3.1.1 [thread.thread.id] just after the
+declaration of
+the comparison operators:
 
    
+
+
    
+template <class T> struct hash;
+template <> struct hash<thread::id>;
+
    
+
    • 
+
+
  • 
 
    
-[2009-03-21 Sat] p1183 thread ctor, and in general, we need a way to
-talk about "copiable from generalized rvalue ref argument" for cases
-where we're going to forward and copy.  
+Add a new paragraph at the end of 30.3.1.1 [thread.thread.id]:
 
    
+
 
    
-
    
-   This issue may well be quite large.  Language in para 4 about "if
-   an lvalue" is wrong because types aren't expressions.
-
    
-
    
-   p1199, call_once has all the same issues.
-
    
-
    
-
    
-[2009-03-21 Sat] p869 InputIterator pointer type should not be required
-to be convertible to const value_type*, rather it needs to have a
-operator-> of its own that can be used for the value type.
-
    
-
    
-[2009-03-21 Sat] p818 stack has the same problem with default ctor.
-
    
-
    
-[2009-03-21 Sat] p816 priority_queue has the same sorts of problems as queue, only more so
-
    
-
       requires MoveConstructible<Cont> 
-     explicit priority_queue(const Compare& x = Compare(), Cont&& = Cont()); 
-
    
-
    
-   Don't require MoveConstructible when default constructing Cont.
-   Also missing semantics for move ctor.
-
    
+
    
+template <> struct hash<thread::id>;
+
    
+
+
    
+An explicit specialization of the class template hash (20.7.16 [unord.hash])
+shall be provided
+for the type thread::id suitable for using this type as key in
+unordered associative
+containers (23.5 [unord]).
+
    
 
    
-
    
- [2009-03-21 Sat] Why are Allocators required to be CopyConstructible as
- opposed to MoveConstructible?
-
    
-
    
- [2009-03-21 Sat] p813 queue needs a separate default ctor (Cont needn't
- be MoveConstructible).  No documented semantics for move c'tor.  Or
- *any* of its 7 ctors!
-
    
-
    
- [2009-03-21 Sat] std::array should have constructors for C++0x,
- consequently must consider move construction.
-
    
+
    • 
 
-
    [
-2009-05-01 Daniel adds:
-]
    
+
  • 
+Issue 889 independently suggests moving the specialization
+std::hash<std::thread::id> to header <thread>.
+
    • 
+
 
 
-
    
-This could be done as part of 1035, which already handles
-deviation of std::array from container tables.
-
    
 
+
    Proposed resolution:
    
 
    
- [2009-03-21 Sat] p622 all messed up.
-
    
-
    
-
    
-   para 8 "implementation-defined" is the wrong term; should be "see
-   below" or something.  
-
    
-
    
-   para 12 "will be selected" doesn't make any sense because we're not
-   talking about actual arg types.
-
    
-
    
-   paras 9-13 need to be totally rewritten for concepts.
+Strike the following specializations declared in the <functional>
+synopsis p2 20.7 [function.objects]
 
    
-
    
+
+
    template <> struct hash<std::string>;
+template <> struct hash<std::u16string>;
+template <> struct hash<std::u32string>;
+template <> struct hash<std::wstring>;
+
+template <class Allocator> struct hash<std::vector<bool, Allocator> >;
+template <std::size_t N> struct hash<std::bitset<N> >;
+
    
 
 
    
- [2009-03-21 Sat] Null pointer comparisons (p587) have all become
- unconstrained.  Need to fix that
-
    
-
    
- [2009-03-21 Sat] mem_fun_t etc. definition doesn't match declaration.
-  We think CopyConstructible is the right reqt.
-
    
-
    
- make_pair needs Constructible<V1, T1&&> requirements!
-
    
-
    
- make_tuple needs something similar
-
    
-
    
- tuple bug in synopsis:
+Add the following declarations to the synopsis of <string> in
+21.3 [string.classes]
 
    
-
       template <class... UTypes>
-   requires Constructible<Types, const UTypes&>...
-   template <class... UTypes>
-   requires Constructible<Types, RvalueOf<UTypes>::type>...
-
    
+
+
    // 21.4.x hash support
+template <class T> struct hash;
+template <> struct hash<string>;
+template <> struct hash<u16string>;
+template <> struct hash<u32string>;
+template <> struct hash<wstring>;
+
    
+
 
    
-   Note: removal of MoveConstructible requirements in std::function makes
-   these routines unconstrained!
+Add a new clause 21.4.X
 
    
-
    
 
-
    [
-2009-05-02 Daniel adds:
-]
    
+
    
+
    
+21.4.X Hash support [basic.string.hash]
+
    
 
+
    template <> struct hash<string>;
+template <> struct hash<u16string>;
+template <> struct hash<u32string>;
+template <> struct hash<wstring>;
+
    
 
 
    
-This part of the issue is already covered by 1077.
+Explicit specializations of the class template hash (20.7.16 [unord.hash])
+shall be provided for the types string, u16string,
+u32string and wstring suitable for using these types as keys in
+unordered associative containers (23.5 [unord]).
+
    
 
    
 
 
    
- these unique_ptr constructors are broken [ I think this is covered in "p622 all messed up" ]
+Add the following declarations to the synopsis of <vector> in 
+23.3 [sequences]
 
    
-
     unique_ptr(pointer p, implementation-defined d);
- unique_ptr(pointer p, implementation-defined d);
-
    
+
+
    
+// 21.4.x hash support
+template <class T> struct hash;
+template <class Allocator> struct hash<vector<bool, Allocator>>;
+
    
+
 
    
- multimap range constructor should not have MoveConstructible<value_type> requirement.
+Add a new paragraph to the end of 23.3.7 [vector.bool]
 
    
+
+
    template <class Allocator> struct hash<vector<bool, Allocator>>;
+
    
 
    
-   same with insert(..., P&&); multiset has the same issue, as do
-   unordered_multiset and unordered_multimap. Review these!
+A partial specialization of the class template hash (20.7.16 [unord.hash])
+shall be provided for vectors of boolean values suitable for use as a key
+in unordered associative containers (23.5 [unord]).
 
    
-
 
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    
+Add the following declarations to the synopsis of <bitset>
+in 20.3.7 [template.bitset]
+
    
 
-
    
-Move to Open, pending proposed wording from Dave for further review.
-
    
+
    
+// 20.3.6.X hash support
+template <class T> struct hash;
+template <size_t N> struct hash<bitset<N> >;
+
    
 
+
    
+Add a new subclause 20.3.6.X [bitset.hash]
+
    
 
-
    Proposed resolution:
    
+
    
 
    
+20.3.6.X bitset hash support [bitset.hash]
 
    
 
+
    template <size_t N> struct hash<bitset<N> >;
+
    
+
+
    
+A partial specialization of the class template hash
+(20.7.16 [unord.hash]) shall be provided for bitsets suitable for use as a key in
+unordered associative containers (23.5 [unord]).
+
    
+
    
+
+
 
 
 
 
 
    
-
    1100. auto_ptr to unique_ptr conversion
    
-
    Section: 20.8.9.2.1 [unique.ptr.single.ctor] Status: Review
- Submitter: Howard Hinnant Opened: 2009-04-25  Last modified: 2009-08-01
    
-
    View other active issues in [unique.ptr.single.ctor].
    
-
    View all other issues in [unique.ptr.single.ctor].
    
-
    View all issues with Review status.
    
+
    1183. basic_ios::set_rdbuf may break class invariants
    
+
    Section: 27.5.4.2 [basic.ios.members] Status: Open
+ Submitter: Daniel Krügler Opened: 2009-07-28  Last modified: 2009-10-22
    
+
    View other active issues in [basic.ios.members].
    
+
    View all other issues in [basic.ios.members].
    
+
    View all issues with Open status.
    
 
    Discussion:
    
 
    
-Message c++std-lib-23182 led to a discussion in which several people
-expressed interest in being able to convert an auto_ptr to a
-unique_ptr without the need to call release.  Below is
-wording to accomplish this.
+The protected member function set_rdbuf had been added during the
+process of adding move and swap semantics to IO classes. A relevant
+property of this function is described by it's effects in
+27.5.4.2 [basic.ios.members]/19:
 
    
 
-
    [
-Batavia (2009-05):
-]
    
-
 
    
+Effects: Associates the basic_streambuf object pointed to by sb with
+this stream without calling clear().
+
    
+
 
    
-Pete believes it not a good idea to separate parts of a class's definition.
-Therefore, if we do this,
-it should be part of unique-ptr's specification.
+This means that implementors of or those who derive from existing IO classes
+could cause an internal state where the stream buffer could be 0, but the
+IO class has the state good(). This would break several currently existing
+implementations which rely on the fact that setting a stream buffer via the
+currently only ways, i.e. either by calling
 
    
+
+
    void init(basic_streambuf<charT,traits>* sb);
+
    
+
 
    
-Alisdair believes the lvalue overload may be not necessary.
+or by calling
 
    
+
+
    basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
+
    
+
 
    
-Marc believes it is more than just sugar,
-as it does ease the transition to unique-ptr.
+to set rdstate() to badbit, if the buffer is 0. This has the effect that many
+internal functions can simply check rdstate() instead of rdbuf() for being 0.
 
    
+
 
    
-We agree with the resolution as presented.
-Move to Tentatively Ready.
+I therefore suggest that a requirement is added for callers of set_rdbuf to
+set a non-0 value.
 
    
-
    
 
 
    [
-2009-07 Frankfurt
+2009-10 Santa Cruz:
 ]
    
 
 
 
    
-Moved from Tentatively Ready to Open only because the wording needs to be
-tweaked for concepts removal.
+Moved to Open.  Martin volunteers to provide new wording, where
+set_rdbuf() sets the badbit but does not cause an
+exception to be thrown like a call to clear() would.
 
    
 
 
    [
-2009-08-01 Howard deconceptifies wording:
+2009-10-20 Martin provides wording:
 ]
    
 
 
+
+
+
    Proposed resolution:
    
+
    
+Change 27.5.4.2 [basic.ios.members] around p. 19 as indicated:
+
    
+
+
    void set_rdbuf(basic_streambuf<charT, traits>* sb);
+
    
+
 
    
-I also moved the change from D.9 [depr.auto.ptr]
-to 20.8.9.2 [unique.ptr.single] per the Editor's request
-in Batavia (as long as I was making changes anyway).  Set back
-to Review.
-
    
+
    
+Effects: Associates the basic_streambuf object pointed
+to by sb with this stream without calling clear().
+Postconditions: rdbuf() == sb.
+
    
 
+
    
+Effects: As if:
+
    
 
+
    
+iostate state = rdstate();
+try { rdbuf(sb); }
+catch(ios_base::failure) {
+   if (0 == (state & ios_base::badbit))
+       unsetf(badbit);
+}
+
    
 
-
    Proposed resolution:
    
 
    
-Add to 20.8.9.2 [unique.ptr.single]:
+Throws: Nothing.
 
    
 
-
    template <class T, class D>
-class unique_ptr
-{
-public:
-    template <class U>
-      unique_ptr(auto_ptr<U>& u);
-    template <class U>
-      unique_ptr(auto_ptr<U>&& u);
-};
-
    
+
    
+
    
+
+
+
    Rationale:
    
+We need to be able to call set_rdbuf() on stream objects
+for which (rdbuf() == 0) holds without causing ios_base::failure to
+be thrown. We also don't want badbit to be set as a result of
+setting rdbuf() to 0 if it wasn't set before the call. This changed
+Effects clause maintains the current behavior (as of N2914) without
+requiring that sb be non-null.
+
+
+
 
+
+
    
+
    1185. iterator categories and output iterators
    
+
    Section: 24.2 [iterator.requirements] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-07-31  Last modified: 2009-07-31
    
+
    View other active issues in [iterator.requirements].
    
+
    View all other issues in [iterator.requirements].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Add to 20.8.9.2.1 [unique.ptr.single.ctor]:
+(wording relative to
+N2723
+pending new working paper)
 
    
 
-
    template <class U>
-  unique_ptr(auto_ptr<U>& u);
-template <class U>
-  unique_ptr(auto_ptr<U>&& u);
-
    
-
    
 
    
-Effects: Constructs a unique_ptr with u.release().
+According to p3 24.2 [iterator.requirements], Forward iterators,
+Bidirectional iterators and Random Access iterators all satisfy the
+requirements for an Output iterator:
 
    
 
+
    
+XXX iterators satisfy all the requirements of the input and output iterators
+and can be used whenever either kind is specified ...
+
    
+
 
    
-Postconditions: get() ==  the value u.get() had before
-the construciton, modulo any required offset adjustments resulting from the cast from
-U* to T*.  u.get() == nullptr.
+Meanwhile, p4 goes on to contradict this:
 
    
 
+
    
+Besides its category, a forward, bidirectional, or random access
+iterator can also be mutable or constant...
+
    
+
+
    
+... Constant iterators do not satisfy the requirements for output iterators
+
    
+
 
    
-Throws: nothing.
+The latter seems to be the overriding concern, as the iterator tag
+hierarchy does not define forward_iterator_tag as multiply derived from
+both input_iterator_tag and output_iterator_tag.
 
    
 
 
    
-Remarks: U* shall be implicitly convertible to T* and
-D shall be the same type as default_delete<T>, else these
-constructors shall not participate in overload resolution.
+The work on concepts for iterators showed us that output iterator really
+is fundamentally a second dimension to the iterator categories, rather
+than part of the linear input -> forward -> bidirectional ->
+random-access sequence.  It would be good to clear up these words to
+reflect that, and separately list output iterator requirements in the
+requires clauses for the appropriate algorithms and operations.
 
    
-
    
-
    
 
 
+
    Proposed resolution:
    
+
 
 
 
 
 
    
-
    1102. std::vector's reallocation policy still unclear
    
-
    Section: 23.3.6.2 [vector.capacity] Status: Review
- Submitter: Daniel Krügler Opened: 2009-04-20  Last modified: 2009-05-23
    
-
    View all other issues in [vector.capacity].
    
-
    View all issues with Review status.
    
+
    1186. Forward list could model a stack
    
+
    Section: 23.3.5.3 [stack] Status: Tentatively NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-07-31  Last modified: 2009-11-02
    
 
    Discussion:
    
 
    
-I have the impression that even the wording of current draft
-N2857
-does insufficiently express the intent of vector's
-reallocation strategy. This has produced not too old library
-implementations which release memory in the clear() function
-and even modern articles about C++ programming cultivate
-the belief that clear is allowed to do exactly this. A typical
-example is something like this:
-
    
-
-
    const int buf_size = ...;
-std::vector<T> buf(buf_size);
-for (int i = 0; i < some_condition; ++i) {
-  buf.resize(buf_size);
-  write_or_read_data(buf.data());
-  buf.clear(); // Ensure that the next round get's 'zeroed' elements
-}
-
    
-
    
-where still the myth is ubiquitous that buf might be
-allowed to reallocate it's memory *inside* the for loop.
-
    
-
    
-IMO the problem is due to the fact, that
+The library template forward_list could easily model the idea of a
+stack, where the operations work on the front of the list rather than
+the back.  However, the standard library stack adaptor cannot support
+this.
 
    
 
-
      
-
    1. 
-the actual memory-reallocation stability of std::vector
-is explained in 23.3.6.2 [vector.capacity]/3 and /6 which
-are describing just the effects of the reserve
-function, but in many examples (like above) there
-is no explicit call to reserve involved. Further-more
-23.3.6.2 [vector.capacity]/6 does only mention insertions
-and never mentions the consequences of erasing
-elements.
-
      2. 
-
    2. 
 
      
-the effects clause of std::vector's erase overloads in
-23.3.6.4 [vector.modifiers]/4 is silent about capacity changes. This
-easily causes a misunderstanding, because the counter
-parting insert functions described in 23.3.6.4 [vector.modifiers]/2
-explicitly say, that
+It would be relatively easy to write a partial specialization for stack
+to support forward_list, but that opens the question of which header to
+place it in.  A much better solution would be to add a concept_map for
+the StackLikeContainer concept to the <forward_list> header and then
+everything just works, including a user's own further uses in a
+stack-like context.
 
      
-
      
-Causes reallocation if the new size is greater than the
-old capacity. If no reallocation happens, all the iterators
-and references before the insertion point remain valid.
-
      
+
 
      
-It requires a complex argumentation chain about four
-different places in the standard to provide the - possibly
-weak - proof that calling clear() also does never change
-the capacity of the std::vector container. Since std::vector
-is the de-facto replacement of C99's dynamic arrays this
-type is near to a built-in type and it's specification should
-be clear enough that usual programmers can trust their
-own reading.
+Therefore while I am submitting the issue now so that it is on record, I
+strongly recommend we resolve as "NAD Concepts" as any non-concepts
+based solution will be inferior to the final goal, and the feature is
+not so compelling it must be supported ahead of the concepts-based
+library.
 
      
-
      3. 
-
    
 
 
    [
-Batavia (2009-05):
+2009-11-02 Howard adds:
 ]
    
 
+
 
    
-
    
-Bill believes paragraph 1 of the proposed resolution is unnecessary
-because it is already implied (even if tortuously) by the current wording.
-
    
-
    
-Move to Review.
-
    
+Moved to Tentatively NAD Concepts after 5 positive votes on c++std-lib.
 
    
 
 
 
    Proposed resolution:
    
-
    [
-This is a minimum version. I also
-suggest that the wording explaining the allocation strategy
-of std::vector in 23.3.6.2 [vector.capacity]/3 and /6 is moved into
-a separate sub paragraph of 23.3.6.2 [vector.capacity] before
-any of the prototype's are discussed, but I cannot provide
-reasonable wording changes now
-]
    
 
 
-
      
-
    1. 
+
+
+
+
      
+
      1187. std::decay
      
+
      Section: 20.6.7 [meta.trans.other] Status: New
+ Submitter: Jason Merrill Opened: 2009-08-07  Last modified: 2009-08-22
      
+
      View all other issues in [meta.trans.other].
      
+
      View all issues with New status.
      
+
      Discussion:
      
 
      
-Change 23.3.6.2 [vector.capacity]/6 as follows:
+I notice that std::decay is specified to strip the cv-quals from
+anything but an array or pointer.  This seems incorrect for values of
+class type, since class rvalues can have cv-qualified type (3.10 [basic.lval]/9).
 
      
+
+
      [
+2009-08-09 Howard adds:
+]
      
+
+
 
      
-It is guaranteed that no reallocation takes place during
-insertions or erasures that happen after a call
-to reserve() until the time when an insertion would make
-the size of the vector greater than the value of capacity().
+See the thread starting with c++std-lib-24568 for further discussion.  And
+here is a convenience link to the
+original proposal.
+Also see the closely related issue 705.
 
      
-
      2. 
-
    2. 
+
+
+
      Proposed resolution:
      
+
 
      
-Change 23.3.6.4 [vector.modifiers]/4 as follows:
+Add a note to decay in 20.6.7 [meta.trans.other]:
 
      
+
 
      
-Effects: The capacity shall remain unchanged and no reallocation shall
-happen.
-Invalidates iterators and references at or after the point
-of the erase.
+[Note: This behavior is similar to the lvalue-to-rvalue (4.1),
+array-to-pointer (4.2), and function-to-pointer (4.3) conversions
+applied when an lvalue expression is used as an rvalue, but also strips
+cv-qualifiers from class types in order to more closely model by-value
+argument passing. — end note]
 
      
-
      3. 
-
    
+
+
+
 
 
 
 
 
 
    
-
    1104. basic_ios::move should accept lvalues
    
-
    Section: 27.5.4.2 [basic.ios.members] Status: Review
- Submitter: Howard Hinnant Opened: 2009-04-25  Last modified: 2009-05-23
    
-
    View other active issues in [basic.ios.members].
    
-
    View all other issues in [basic.ios.members].
    
-
    View all issues with Review status.
    
+
    1188. Unordered containers should have a minimum load factor as well as a maximum
    
+
    Section: 23.2.5 [unord.req], 23.5 [unord] Status: New
+ Submitter: Matt Austern Opened: 2009-08-10  Last modified: 2009-08-11
    
+
    View other active issues in [unord.req].
    
+
    View all other issues in [unord.req].
    
+
    View all issues with New status.
    
 
    Discussion:
    
 
    
-With the rvalue reference changes in
-N2844
-basic_ios::move no longer has the most convenient signature:
+Unordered associative containers have a notion of a maximum load factor:
+when the number of elements grows large enough, the containers
+automatically perform a rehash so that the number of elements per bucket
+stays below a user-specified bound. This ensures that the hash table's
+performance characteristics don't change dramatically as the size
+increases.
 
    
 
-
    void move(basic_ios&& rhs);
-
    
-
 
    
-This signature should be changed to accept lvalues.  It does not need to be
-overloaded to accept rvalues.  This is a special case that only derived clients
-will see.  The generic move still needs to accept rvalues.
+For similar reasons, Google has found it useful to specify a minimum
+load factor: when the number of elements shrinks by a large enough, the
+containers automatically perform a rehash so that the number of elements
+per bucket stays above a user-specified bound. This is useful for two
+reasons. First, it prevents wasting a lot of memory when an unordered
+associative container grows temporarily. Second, it prevents amortized
+iteration time from being arbitrarily large; consider the case of a hash
+table with a billion buckets and only one element. (This was discussed
+even before TR1 was published; it was TR issue 6.13, which the LWG
+closed as NAD on the grounds that it was a known design feature.
+However, the LWG did not consider the approach of a minimum load
+factor.)
 
    
 
-
    [
-Batavia (2009-05):
-]
    
-
-
    
 
    
-Tom prefers, on general principles, to provide both overloads.
-Alisdair agrees.
+The only interesting question is when shrinking is allowed. In principle
+the cleanest solution would be shrinking on erase, just as we grow on
+insert. However, that would be a usability problem; it would break a
+number of common idioms involving erase. Instead, Google's hash tables
+only shrink on insert and rehash.
 
    
+
 
    
-Howard points out that there is no backward compatibility issue
-as this is new to C++0X.
+The proposed resolution allows, but does not require, shrinking in
+rehash, mostly because a postcondition for rehash that involves the
+minimum load factor would be fairly complicated. (It would probably have
+to involve a number of special cases and it would probably have to
+mention yet another parameter, a minimum bucket count.)
 
    
+
 
    
-We agree that both overloads should be provided,
-and Howard will provide the additional wording.
-Move to Open.
+The current behavior is equivalent to a minimum load factor of 0. If we
+specify that 0 is the default, this change will have no impact on
+backward compatibility.
 
    
-
    
-
-
    [
-2009-05-23 Howard adds:
-]
    
-
-
-
    
-Added overload, moved to Review.
-
    
-
 
 
 
    Proposed resolution:
    
 
    
-Add a signature to the existing prototype in the synopsis of 27.5.4 [ios]
-and in 27.5.4.2 [basic.ios.members]:
+Add two new rows, and change rehash's postcondition in the unordered
+associative container requirements table in 23.2.5 [unord.req]:
 
    
 
-
    void move(basic_ios& rhs);
-void move(basic_ios&& rhs);
-
    
-
-
+
    
+
+
 
+
+
+
+
+
+
+
+
+
+
 
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 87 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    
+a.min_load_factor()
+
+float
+
+Returns a non-negative number that the container attempts to keep the
+load factor greater than or equal to. The container automatically
+decreases the number of buckets as necessary to keep the load factor
+above this number.
+
+constant
+
    a.min_load_factor(z)voidPre: z shall be non-negative. Changes the container's minimum
+load factor, using z as a hint. [Footnote: the minimum
+load factor should be significantly smaller than the maximum. 
+If z is too large, the implementation may reduce it to a more sensible value.]
+
+constant
+
    a.rehash(n)void
+Post: a.bucket_count() >= n, and a.size() <= a.bucket_count()
+* a.max_load_factor(). [Footnote: It is intentional that the
+postcondition does not mention the minimum load factor.
+This member function is primarily intended for cases where the user knows
+that the container's size will increase soon, in which case the container's
+load factor will temporarily fall below a.min_load_factor().]
+
+a.bucket_cout > a.size() / a.max_load_factor() and a.bucket_count()
+>= n.
+
+
+Average case linear in a.size(), worst case quadratic.
+
    
+
    
 
-
    
-
    1106. Multiple exceptions from connected shared_future::get()?
    
-
    Section: 30.6.6 [future.shared_future] Status: Open
- Submitter: Thomas J. Gritzan Opened: 2009-04-03  Last modified: 2009-05-23
    
-
    View other active issues in [future.shared_future].
    
-
    View all other issues in [future.shared_future].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
 
    
-It is not clear, if multiple threads are waiting in a 
-shared_future::get() call, if each will rethrow the stored exception.
-
    
-
    
-Paragraph 9 reads: 
+Add a footnote to 23.2.5 [unord.req] p12:
 
    
+
 
    
-Throws: the stored exception, if an exception was stored and not 
-retrieved before.
-
    
-
    
-The "not retrieved before" suggests that only one exception is thrown, 
-but one exception for each call to get() is needed, and multiple calls 
-to get() even on the same shared_future object seem to be allowed. 
-
    
 
    
-I suggest removing "and not retrieved before" from the Throws paragraph. 
-I recommend adding a note that explains that multiple calls on get() are 
-allowed, and each call would result in an exception if an exception was 
-stored. 
+The insert members shall not affect the validity of references to
+container elements, but may invalidate all iterators to the container.
+The erase members shall invalidate only iterators and references to the
+erased elements.
 
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    
+[A consequence of these requirements is that while insert may change the
+number of buckets, erase may not. The number of buckets may be reduced
+on calls to insert or rehash.]
+
    
+
    
 
-
    
-
    
-We note there is a pending paper by Detlef
-on such future-related issues;
-we would like to wait for his paper before proceeding.
-
    
 
    
-Alisdair suggests we may want language to clarify that this
-get() function can be called from several threads
-with no need for explicit locking.
+Change paragraph 13:
 
    
+
+
    
+The insert members shall not affect the validity of iterators if
+(N+n) < z * B zmin * B <= (N+n) <= zmax * B,
+where N is the number of elements in
+the container prior to the insert operation, n is the number of
+elements inserted, B is the container's bucket count,
+zmin is the container's minimum load factor,
+and zmax is the container's maximum load factor.
+
    
+
 
    
-Move to Open.
+Add to the unordered_map class synopsis in section 23.5.1 [unord.map],
+the unordered_multimap class synopsis
+in 23.5.2 [unord.multimap], the unordered_set class synopsis in
+23.5.3 [unord.set], and the unordered_multiset class synopsis
+in 23.5.4 [unord.multiset]:
 
    
-
    
 
+
    
+float min_load_factor() const;
+void min_load_factor(float z);
+
    
 
-
    Proposed resolution:
    
 
    
-Change 30.6.6 [future.shared_future]:
+In 23.5.1.1 [unord.map.cnstr], 23.5.2.1 [unord.multimap.cnstr], 23.5.3.1 [unord.set.cnstr], and
+23.5.4.1 [unord.multiset.cnstr], change:
 
    
 
-
    const R& shared_future::get() const; 
-R& shared_future<R&>::get() const; 
-void shared_future<void>::get() const;
-
    
 
    
-
    ...
    
-
    
--9- Throws: the stored exception, if an exception was stored and not retrieved before.
-
-[Note: Multiple calls on get() are 
-allowed, and each call would result in an exception if an exception was 
-stored. — end note]
-
-
    
-
    
+... max_load_factor() returns 1.0 and
+min_load_factor() returns 0.
 
    
 
 
 
 
 
-
 
    
-
    1108. thread.req.exception overly constrains implementations
    
-
    Section: 30.2.2 [thread.req.exception] Status: Open
- Submitter: Christopher Kohlhoff Opened: 2009-04-25  Last modified: 2009-05-23
    
-
    View all issues with Open status.
    
+
    1189. Awkward interface for changing the number of buckets in an unordered associative container
    
+
    Section: 23.2.5 [unord.req], 23.5 [unord] Status: Tentatively Ready
+ Submitter: Matt Austern Opened: 2009-08-10  Last modified: 2009-10-28
    
+
    View other active issues in [unord.req].
    
+
    View all other issues in [unord.req].
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
    
-The current formulation of 30.2.2 [thread.req.exception]/2 reads:
+Consider a typical use case: I create an unordered_map and then start
+adding elements to it one at a time. I know that it will eventually need
+to store a few million elements, so, for performance reasons, I would
+like to reserve enough capacity that none of the calls to insert will
+trigger a rehash.
 
    
-
    
-The error_category of the error_code reported by such an
-exception's code() member function is as specified in the error
-condition Clause.
-
    
+
 
    
-This constraint on the code's associated error_categor means an
-implementation must perform a mapping from the system-generated
-error to a generic_category() error code. The problems with this
-include:
+Unfortunately, the existing interface makes this awkward. The user
+naturally sees the problem in terms of the number of elements, but the
+interface presents it as buckets. If m is the map and n is the expected
+number of elements, this operation is written m.rehash(n /
+m.max_load_factor()) — not very novice friendly.
 
    
 
-
      
-
    • 
-The mapping is always performed, even if the resultant value is
- never used.
-
      • 
+
      [
+2009-09-30 Daniel adds:
+]
      
+
+
+
      
+I recommend to replace "resize" by a different name like
+"reserve", because that would better match the intended
+use-case. Rational: Any existing resize function has the on-success
+post-condition that the provided size is equal to size(), which
+is not satisfied for the proposal. Reserve seems to fit the purpose of
+the actual renaming suggestion.
+
      
+
+
      [
+2009-10-28 Ganesh summarizes alternative resolutions and expresses a
+strong preference for the second (and opposition to the first):
+]
      
+
+
+
      
+
        
 
      1. 
 
        
-The original error produced by the operating system is lost.
+In the unordered associative container requirements (23.2.5 [unord.req]),
+remove the row for
+rehash and replace it with:
 
        
-
        2. 
-
    
+
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 87 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    a.rehashreserve(n)void
+Post: a.bucket_count > max(a.size(), n)
+/ a.max_load_factor() and a.bucket_count()
+>= n.
+
+Average case linear in a.size(), worst case quadratic.
+
    
+
    
+
 
    
-The latter was one of Peter Dimov's main objections (in a private
-email discussion) to the original error_code-only design, and led to
-the creation of error_condition in the first place. Specifically,
-error_code and error_condition are intended to perform the following
-roles:
+Make the corresponding change in the class synopses in 23.5.1
+[unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4
+[unord.multiset].
 
    
-
      
-
    • 
-error_code holds the original error produced by the operating
- system.
 
      • 
 
    • 
-error_condition and the generic category provide a set of well
- known error constants that error codes may be tested against.
-
      • 
-
    
+
 
    
-Any mapping determining correspondence of the returned error code to
-the conditions listed in the error condition clause falls under the
-"latitude" granted to implementors in 19.5.1.5 [syserr.errcat.objects].
-(Although obviously their latitude is restricted a little by the
-need to match the right error condition when returning an error code
-from a library function.)
+In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:
 
    
+
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 87 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    a.rehash(n)void
+Post: a.bucket_count > a.size()
+/ a.max_load_factor() and a.bucket_count()
+>= n.
+
+Average case linear in a.size(), worst case quadratic.
+
    
+a.reserve(n)
+
+void
+
+Same as a.rehash(ceil(n / a.max_load_factor()))
+
+Average case linear in a.size(), worst case quadratic.
+
    
+
    
+
 
    
-It is important that this error_code/error_condition usage is done
-correctly for the thread library since it is likely to set the
-pattern for future TR libraries that interact with the operating
-system.
+In 23.5.1 [unord.map]/3 in the definition of class template unordered_map, in
+23.5.2 [unord.multimap]/3 in the definition of class template unordered_multimap, in
+23.5.3 [unord.set]/3 in the definition of class template unordered_set and in
+23.5.4 [unord.multiset]/3 in the definition of class template unordered_multiset, add the
+following line after member function rehash():
 
    
 
+
    void reserve(size_type n);
+
    
+
+
+
+
    
+
 
    [
-Batavia (2009-05):
+2009-10-28 Howard:
 ]
    
 
+
 
    
-Move to Open, and recommend the issue be deferred until after the next
-Committee Draft is issued.
-
    
+
    
+Moved to Tentatively Ready after 5 votes in favor of Ganesh's option 2 above.
+The original proposed wording now appears here:
+
    
 
+
    
+
    
+Informally: instead of providing rehash(n) provide resize(n), with the
+semantics "make the container a good size for n elements".
+
    
 
-
    Proposed resolution:
    
 
    
-Change 30.2.2 [thread.req.exception]/2:
+In the unordered associative container requirements (23.2.5 [unord.req]),
+remove the row for
+rehash and replace it with:
 
    
 
 
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 87 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    a.rehashresize(n)void
+Post: a.bucket_count > max(a.size(), n)
+/ a.max_load_factor() and a.bucket_count()
+>= n.
+
+Average case linear in a.size(), worst case quadratic.
+
    
+
    
+
+
    Make the corresponding change in the class synopses in 23.5.1
+[unord.map], 23.5.2 [unord.multimap], 23.5.3 [unord.set], and 23.5.4
+[unord.multiset].
+
    
+
+
    
+
    
+
+
+
    Proposed resolution:
    
 
    
--2- The error_category (19.5.1.1) of the error_code reported by
-such an exception's code() member function 
-is as specified in the error condition Clause.
-
-The error_code reported by such an exception's code() member
-function shall compare equal to one of the conditions specified in
-the function's error condition Clause. [Example: When the thread
-constructor fails:
-
+In 23.2.5 [unord.req]/9, table 98, append a new row after the last one:
 
    
-
    
-ec.category() == implementation-defined // probably system_category
-ec == errc::resource_unavailable_try_again // holds true
-
    
 
-
    
-— end example]
-
    
+
    
+
+
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 87 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    a.rehash(n)void
+Post: a.bucket_count > a.size()
+/ a.max_load_factor() and a.bucket_count()
+>= n.
+
+Average case linear in a.size(), worst case quadratic.
+
    
+a.reserve(n)
+
+void
+
+Same as a.rehash(ceil(n / a.max_load_factor()))
+
+Average case linear in a.size(), worst case quadratic.
+
    
 
    
 
+
    
+In 23.5.1 [unord.map]/3 in the definition of class template unordered_map, in
+23.5.2 [unord.multimap]/3 in the definition of class template unordered_multimap, in
+23.5.3 [unord.set]/3 in the definition of class template unordered_set and in
+23.5.4 [unord.multiset]/3 in the definition of class template unordered_multiset, add the
+following line after member function rehash():
+
    
+
+
    void reserve(size_type n);
+
    
 
 
 
 
 
 
    
-
    1110. Is for_each overconstrained?
    
-
    Section: 25.3.4 [alg.foreach] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-04-29  Last modified: 2009-05-23
    
-
    View all other issues in [alg.foreach].
    
-
    View all issues with Open status.
    
+
    1190. Setting the maximum load factor should return the previous value
    
+
    Section: 23.2.5 [unord.req], 23.5 [unord] Status: New
+ Submitter: Matt Austern Opened: 2009-08-10  Last modified: 2009-08-11
    
+
    View other active issues in [unord.req].
    
+
    View all other issues in [unord.req].
    
+
    View all issues with New status.
    
 
    Discussion:
    
 
    
-Quoting working paper for reference (25.3.4 [alg.foreach]):
+The unordered associative container requirements table specifies that
+a.set_max_load_factor(z) has return type void. However, there is a
+useful piece of information to return: the previous value. Users who
+don't need it can always ignore it.
 
    
 
-
    
-
    template<InputIterator Iter, Callable<auto, Iter::reference> Function>
-  requires CopyConstructible<Function>
-  Function for_each(Iter first, Iter last, Function f);
-
    
-
    
+
+
    Proposed resolution:
    
 
    
-1 Effects: Applies f to the result of dereferencing every iterator in the
- range [first,last), starting from first and proceeding to last - 1.
+In the unordered associative container requirements table, change:
 
    
+
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 87 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    a.max_load_factor(z)void floatPre: z shall be positive. Changes the container's maximum
+load load factor, using z as a hint.
+Returns: the previous value of
+a.max_load_factor().
+
+constant
+
    
+
    
+
 
    
-2 Returns: f.
+Change the return type of set_max_load_factor
+in the class synopses in 23.5.1 [unord.map], 23.5.2 [unord.multimap],  23.5.3 [unord.set],
+and 23.5.4 [unord.multiset].
 
    
+
 
    
-3 Complexity: Applies f exactly last - first times.
+If issue 1188 is also accepted, make the same changes for
+min_load_factor.
 
    
-
    
-
    
 
+
+
+
+
+
    
+
    1191. tuple get API should respect rvalues
    
+
    Section: 20.5.2.6 [tuple.elem] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-08-18  Last modified: 2009-10-31
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-P2 implies the passed object f should be invoked at each stage, rather than
-some copy of f.  This is important if the return value is to usefully
-accumulate changes.  So the requirements are an object of type Function can
-be passed-by-value, invoked multiple times, and then return by value.  In
-this case, MoveConstructible is sufficient. This would open support for
-move-only functors, which might become important in concurrent code as you
-can assume there are no other references (copies) of a move-only type and so
-freely use them concurrently without additional locks.
+The tuple get API should respect rvalues.  This would allow for moving a
+single element out of a tuple-like type.
 
    
 
 
    [
-See further discussion starting with c++std-lib-23686.
+2009-10-30 Alisdair adds:
 ]
    
 
 
-
    [
-Batavia (2009-05):
-]
    
-
 
    
 
    
-Pete suggests we may want to look at this in a broader context
-involving other algorithms.
-We should also consider the implications of parallelism.
+The issue of rvalue overloads of get for tuple-like types was briefly
+discussed in Santa Cruz.
 
    
+
 
    
-Move to Open, and recommend the issue be deferred until after the next
-Committee Draft is issued.
+The feedback was this would be welcome, but we need full wording for the
+other types (pair and array) before advancing.
+
    
+
+
    
+I suggest the issue moves to Open from New as it has been considered,
+feedback given, and it has not (yet) been rejected as NAD.
 
    
 
    
 
 
+
 
    Proposed resolution:
    
 
    
-Change 25.2 [algorithms.syn] and 25.3.4 [alg.foreach]:
+Add the following signature to p2 20.5.1 [tuple.general]
 
    
 
-
    template<InputIterator Iter, Callable<auto, Iter::reference> Function>
-  requires CopyConstructible MoveConstructible<Function>
-  Function for_each(Iter first, Iter last, Function f);
-
    
+
    
+template <size_t I, class ... Types>
+typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...> &&);
+
    
 
+
    
+And again to 20.5.2.6 [tuple.elem].
+
    
 
+
    
+template <size_t I, class ... Types>
+typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&& t);
+
    
 
+
    
+
    
+Effects: Equivalent to return std::forward<typename tuple_element<I, tuple<Types...> >::type&&>(get<I>(t));
+
    
 
 
-
    
-
    1112. bitsets and new style for loop
    
-
    Section: 20.3.6 [template.bitset] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-05-06  Last modified: 2009-07-25
    
-
    View other active issues in [template.bitset].
    
-
    View all other issues in [template.bitset].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
-
    
-Std::bitset is a homogeneous container-like sequence of bits, yet it does
-not model the Range concept so cannot be used with the new for-loop syntax.
-It is the only such type in the library that does NOT support the new for
-loop.
-
    
-
    
-The obvious reason is that bitset does not support iterators.
-
    
-
    
-At least two reasonable solutions are available:
-
    
-
      
-
    1. 
-Add an iterator interface to bitset, bringing its interface close to that
-of std::array
-
      2. 
-
    2. 
-Provide an unspecified concept_map for Range<bitset>.
-
      3. 
-
    
+
    
+[Note: If a T in Types is some reference type X&,
+the return type is X&, not X&&.
+However, if the element type is non-reference type T,
+the return type is T&&. — end note]
+
    
+
+
    
+
    
+
 
    
-The latter will still need some kind of iterator-like adapter for bitset,
-but gives implementers greater freedom on the details. E.g. begin/end return
-some type that simply invokes operator[] on the object it wraps, and
-increments its index on operator++.  A vendor can settle for InputIterator
-support, rather than wrapping up a full RandomAccessIterator.
+Add the following signature to p1 20.3 [utility]
 
    
+
+
    
+template <size_t I, class T1, class T2>
+typename tuple_element<I, pair<T1,T2> >::type&& get(pair<T1, T2>&&);
+
    
+
 
    
-I have a mild preference for option (ii) as I think it is less work to
-specify at this stage of the process, although (i) is probably more useful
-in the long run.
+And to p5 20.3.5 [pair.astuple]
 
    
+
+
    
+template <size_t I, class T1, class T2>
+typename tuple_element<I, pair<T1,T2> >::type&& get(pair<T1, T2>&& p);
+
    
+
+
    
+
    
+Returns: If I == 0 returns std::forward<T1&&>(p.first);
+if I == 1
+returns std::forward<T2&&>(p.second); otherwise the program is ill-formed.
+
    
+
+
    
+Throws: Nothing.
+
    
+
+
    
+
+
    
+
 
    
-Hmm, my wording looks a little woolly, as it does not say what the element
-type of the range is.  Do I get a range of bool, bitset<N>::reference, or
-something else entirely?
+Add the following signature to 23.3 [sequences] <array> synopsis
 
    
+
+
    template <size_t I, class T, size_t N>
+T&& get(array<T,N> &&);
+
    
+
 
    
-I guess most users will assume the behaviour of reference, but expect to
-work with bool.  Bool is OK for read-only traversal, but you really need to
-take a reference to a bitset::reference if you want to write back.
+And after p8 23.3.1.7 [array.tuple]
 
    
 
-
    [
-Batavia (2009-05):
-]
    
+
    template <size_t I, class T, size_t N>
+T&& get(array<T,N> && a);
+
    
 
-
    
-Move to Open.
-We further recommend this be deferred until after the next Committee Draft.
+
    
+Effects: Equivalent to return std::move(get<I>(a));
+
    
 
    
 
-
    [
-2009-05-25 Alisdair adds:
-]
    
 
 
-
    
+
+
+
+
    
+
    1192. basic_string missing definitions for cbegin / cend / crbegin / crend
    
+
    Section: 21.4.3 [string.iterators] Status: Tentatively Ready
+ Submitter: Jonathan Wakely Opened: 2009-08-14  Last modified: 2009-10-29
    
+
    View all issues with Tentatively Ready status.
    
+
    Discussion:
    
 
    
-I just stumbled over the Range concept_map for valarray and this should
-probably set the precedent on how to write the wording.
+Unlike the containers in clause 23, basic_string has definitions for
+begin() and end(), but these have not been updated to include cbegin,
+cend, crbegin and crend.
 
    
 
 
    [
-Howard: I've replaced the proposed wording with Alisdair's suggestion.
+2009-10-28 Howard:
 ]
    
 
 
+
    
+Moved to Tentatively NAD after 5 positive votes on c++std-lib.  Added
+rationale.
 
    
 
 
    [
-2009-07-24 Daniel modifies the proposed wording for non-concepts.
+2009-10-28 Alisdair disagrees:
 ]
    
 
 
+
    
+
    
+I'm going to have to speak up as the dissenting voice.
+
    
 
-
-
    Proposed resolution:
    
-
      
-
    1. 
 
      
-Modify the section 20.3.6 [template.bitset] <bitset> synopsis by adding
-the following at the end of the synopsis:
+I agree the issue could be handled editorially, and that would be my
+preference if Pete feels this is appropriate. Failing that, I really
+think this issue should be accepted and moved to ready.  The other
+begin/end functions all have a semantic definition for this template,
+and it is confusing if a small few are missing.
 
      
-
      
-// XX.X.X bitset range access [bitset.range]
-template<size_t N> unspecified-1 begin(bitset<N>&);
-template<size_t N> unspecified-2 begin(const bitset<N>&);
-template<size_t N> unspecified-1 end(bitset<N>&);
-template<size_t N> unspecified-2 end(const bitset<N>&);
-
-
      
-
      2. 
-
    2. 
+
 
      
-Add a new section "bitset range access" [bitset.range]
-after the current section 20.3.6.3 [bitset.operators] with the following series of
-paragraphs:
+I agree that an alternative would be to strike all the definitions for
+begin/end/rbegin/rend and defer completely to the requirements tables in
+clause 23.  I think that might be confusing without a forward reference
+though, as those tables are defined in a *later* clause than the
+basic_string template itself.  If someone wants to pursue this I would
+support it, but recommend it as a separate issue.
 
      
-
      
+
 
      
-
-1.  In the begin and end function templates that follow, unspecified-1
-is a type that meets the requirements of a mutable random access
-iterator (24.2.6 [random.access.iterators]) whose value_type is bool and
-whose reference type is bitset<N>::reference.
-unspecified-2 is a type that meets the requirements of a constant
-random access iterator (24.2.6 [random.access.iterators]) whose value_type
-is bool and whose reference type is bool.
-
+So my preference is strongly to move Ready over NAD, and a stronger
+preference for NAD Editorial if Pete is happy to make these changes.
 
      
-
      
-template<size_t N> unspecified-1 begin(bitset<N>&);
-template<size_t N> unspecified-2 begin(const bitset<N>&);
-
-
      
-
      
-2.  Returns: an iterator referencing the first bit in the bitset.
+
 
      
 
-
      
-template<size_t N> unspecified-1 end(bitset<N>&);
-template<size_t N> unspecified-2 end(const bitset<N>&);
-
      
+
      [
+2009-10-29 Howard:
+]
      
+
 
 
      
-3.  Returns: an iterator referencing one past the last bit in the
-bitset.
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.  Removed
+rationale to mark it NAD.  :-)
 
      
-
      
-
      3. 
-
    
 
 
 
+
    Proposed resolution:
    
+
    
+Add to 21.4.3 [string.iterators]
+
    
+
+
    iterator       begin();
+const_iterator begin() const;
+const_iterator cbegin() const;
+
    
+
+
    ...
    
+
+
    iterator       end();
+const_iterator end() const;
+const_iterator cend() const;
+
    
+
+
    ...
    
 
+
    reverse_iterator       rbegin();
+const_reverse_iterator rbegin() const;
+const_reverse_iterator crbegin() const;
+
    
 
+
    ...
    
 
+
    reverse_iterator       rend();
+const_reverse_iterator rend() const;
+const_reverse_iterator crend() const;
+
    
 
+
    
 
 
 
 
 
 
    
-
    1113. bitset::to_string could be simplified
    
-
    Section: 20.3.6 [template.bitset] Status: Open
- Submitter: Alisdair Meredith Opened: 2009-05-09  Last modified: 2009-05-23
    
-
    View other active issues in [template.bitset].
    
-
    View all other issues in [template.bitset].
    
-
    View all issues with Open status.
    
+
    1193. default_delete cannot be instantiated with  incomplete types
    
+
    Section: 20.8.14.1 [unique.ptr.dltr] Status: New
+ Submitter: Daniel Krügler Opened: 2009-08-18  Last modified: 2009-08-22
    
+
    View all issues with New status.
    
 
    Discussion:
    
 
    
-In 853 our resolution is changing the signature by adding two
-defaulting arguments to 3 calls.  In principle, this means that ABI breakage
-is not an issue, while API is preserved.
+According to the general rules of 17.6.3.8 [res.on.functions]/2 b 5 the effects
+are undefined, if an incomplete type is used to instantiate a library template. But neither in
+20.8.14.1 [unique.ptr.dltr] nor
+in any other place of the standard such explicit allowance is given.
+Since this template is intended to be instantiated with incomplete
+types, this must
+be fixed.
 
    
+
+
+
    Proposed resolution:
    
 
    
-With that observation, it would be very nice to use the new ability to
-supply default template parameters to function templates to collapse all 3
-signatures into 1.  In that spirit, this issue offers an alternative resolution
-than that of 853.
+Add two new paragraphs directly to 20.8.14.1 [unique.ptr.dltr] (before
+20.8.14.1.1 [unique.ptr.dltr.dflt]) with the following
+content:
 
    
 
-
    [
-Batavia (2009-05):
-]
    
-
 
    
-Move to Open,
-and look at the issue again after 853 has been accepted.
-We further recommend this be deferred until after the next Committee Draft.
+
    
+The class template default_delete serves as the default deleter (destruction policy) for
+the class template unique_ptr.
+
    
+
+
    
+The template parameter T of default_delete may be an incomplete type.
+
    
 
    
 
 
-
    Proposed resolution:
    
 
-
      
-
    1. 
+
+
+
      
+
      1194. Unintended queue constructor
      
+
      Section: 23.3.5 [container.adaptors] Status: Ready
+ Submitter: Howard Hinnant Opened: 2009-08-20  Last modified: 2009-10-20
      
+
      View other active issues in [container.adaptors].
      
+
      View all other issues in [container.adaptors].
      
+
      View all issues with Ready status.
      
+
      Discussion:
      
 
      
-In 20.3.6 [template.bitset]/1 (class bitset) ammend:
+23.3.5.1.1 [queue.defn] has the following queue constructor:
 
      
-
      template <class charT = char,
-            class traits = char_traits<charT>,
-            class Allocator = allocator<charT>> 
-  basic_string<charT, traits, Allocator>
-  to_string(charT zero = charT('0'), charT one = charT('1')) const;
-template <class charT, class traits> 
-  basic_string<charT, traits, allocator<charT> > to_string() const; 
-template <class charT> 
-  basic_string<charT, char_traits<charT>, allocator<charT> > to_string() const; 
-basic_string<char, char_traits<char>, allocator<char> > to_string() const;
+
+
      template <class Alloc> explicit queue(const Alloc&);
 
      
-
      2. 
-
    2. 
+
 
      
-In 20.3.6.2 [bitset.members] prior to p35 ammend:
+This will be implemented like so:
 
      
-
      template <class charT = char,
-            class traits = char_traits<charT>,
-            class Allocator = allocator<charT>> 
-  basic_string<charT, traits, Allocator>
-  to_string(charT zero = charT('0'), charT one = charT('1')) const;
-
      
-
      3. 
-
    3. 
-Strike 20.3.6.2 [bitset.members] paragraphs 37 -> 39 (including signature
-above 37)
-
      4. 
-
    
-
-
-
 
+
    template <class Alloc> explicit queue(const Alloc& a) : c(a) {}
+
    
 
+
    
+The issue is that Alloc can be anything that a container will construct
+from, for example an int.  Is this intended to compile?
+
    
 
-
    
-
    1114. Type traits underspecified
    
-
    Section: 20.6 [meta] Status: Open
- Submitter: Daniel Krügler Opened: 2009-05-12  Last modified: 2009-05-23
    
-
    View other active issues in [meta].
    
-
    View all other issues in [meta].
    
-
    View all issues with Open status.
    
-
    Discussion:
    
+
    queue<int> q(5);
+
    
 
 
    
-Related to 975 and 1023.
+Before the addition of this constructor, queue<int>(5) would not compile.
+I ask, not because this crashes, but because it is new and appears to be
+unintended.  We do not want to be in a position of accidently introducing this
+"feature" in C++0X and later attempting to remove it.
 
    
 
 
    
-The current wording in 20.6.1 [meta.rqmts] is still unclear concerning
-it's requirements on the type traits classes regarding ambiguities.
-Specifically it's unclear
+I've picked on queue.  priority_queue and stack have
+the same issue.  Is it useful to create a priority_queue of 5
+identical elements?
 
    
 
-
      
-
    • 
-if a predicate trait (20.6.4 [meta.unary], 20.6.5 [meta.rel]) could derive from both
-true_type/false_type.
-
      • 
-
    • 
-if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could ambiguously derive
-from the same specified result type.
-
      • 
-
    • 
-if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could derive from other
-integral_constant types making the contained names ambiguous
-
      • 
-
    • 
-if any of the type traits (20.6.1 [meta.rqmts], 20.6.4 [meta.unary], 20.6.5 [meta.rel]) could have other base
-classes that contain members hiding the name of the result type members
-or make the contained member names ambiguous.
-
      • 
-
    
+
    [
+Daniel, Howard and Pablo collaborated on the proposed wording.
+]
    
+
 
 
    [
-Batavia (2009-05):
+2009-10 Santa Cruz:
 ]
    
 
+
 
    
-
    
-Alisdair would prefer to factor some of the repeated text,
-but modulo a corner case or two,
-he believes the proposed wording is otherwise substantially correct.
-
    
-
    
-Move to Open.
-
    
+Move to Ready.
 
    
 
 
+
 
    Proposed resolution:
    
+
 
    [
-The usage of the notion of a BaseCharacteristic below
-might be
-useful in other places - e.g. to define the base class relation in
-20.7.5 [refwrap], 20.7.15 [func.memfn], or 20.7.16.2 [func.wrap.func].
-In this case it's definition should probably
-be moved to Clause 17
+This resolution includes a semi-editorial clean up, giving definitions to members
+which in some cases weren't defined since C++98.
+This resolution also offers editorially different wording for 976,
+and it also provides wording for 1196.
 ]
    
 
 
-
      
-
    1. 
 
      
-Change 20.6.1 [meta.rqmts]/1 as indicated:
+Change  container.adaptors, p1:
 
      
+
 
      
-[..] It shall be DefaultConstructible, CopyConstructible, and publicly
-and unambiguously derived, directly or indirectly, from
-its BaseCharacteristic, which is a specialization of the
-template integral_constant (20.6.3), with the arguments to the template
-integral_constant determined by the requirements for the particular
-property being described. The member names of the
-BaseCharacteristic shall be unhidden and unambiguously
-available in the UnaryTypeTrait.
+The container adaptors each take a Container template parameter, and
+each constructor takes a Container reference argument. This container is
+copied into the Container member of each adaptor. If the container takes
+an allocator, then a compatible allocator may be passed in to the
+adaptor's constructor. Otherwise, normal copy or move construction is
+used for the container argument. [Note: it is not necessary for an
+implementation to distinguish between the one-argument constructor that
+takes a Container and the one- argument constructor that takes an
+allocator_type. Both forms use their argument to construct an instance
+of the container. — end note]
 
      
-
      2. 
-
    2. 
+
 
      
-Change 20.6.1 [meta.rqmts]/2 as indicated:
+Change  queue.defn, p1:
+
      
+
+
      template <class T, class Container = deque<T> >
+class queue {
+public:
+  typedef typename Container::value_type      value_type;
+  typedef typename Container::reference       reference;
+  typedef typename Container::const_reference const_reference;
+  typedef typename Container::size_type       size_type;
+  typedef Container                           container_type;
+protected:
+  Container c;
+
+public:
+  explicit queue(const Container&);
+  explicit queue(Container&& = Container());
+  queue(queue&& q); : c(std::move(q.c)) {}
+  template <class Alloc> explicit queue(const Alloc&);
+  template <class Alloc> queue(const Container&, const Alloc&);
+  template <class Alloc> queue(Container&&, const Alloc&);
+  template <class Alloc> queue(queue&&, const Alloc&);
+  queue& operator=(queue&& q); { c = std::move(q.c); return *this; }
+
+  bool empty() const          { return c.empty(); }
+  ...
+};
+
      
+
+
      
+Add a new section after 23.3.5.1.1 [queue.defn], [queue.cons]:
 
      
+
 
      
-[..] It shall be DefaultConstructible, CopyConstructible, and publicly
-and unambiguously derived, directly or indirectly, from
-an instance its BaseCharacteristic, which is a
-specialization of the template integral_constant (20.6.3), with
-the arguments to the template integral_constant determined by the
-requirements for the particular relationship being described. The
-member names of the BaseCharacteristic shall be unhidden
-and unambiguously available in the BinaryTypeTrait.
+
      queue constructors [queue.cons]
      
+
+
      explicit queue(const Container& cont);
+
      
+
+
      
+
+
      
+Effects: Initializes c with cont.
+
      
+
 
      
-
      3. 
-
    3. 
+
+
      explicit queue(Container&& cont = Container());
+
      
+
+
      
+
 
      
-Change 20.6.4 [meta.unary]/2 as indicated:
+Effects: Initializes c with std::move(cont).
 
      
+
+
      
+
+
      queue(queue&& q)
+
      
+
 
      
-Each of these templates shall be a UnaryTypeTrait (20.6.1),
-publicly derived directly or indirectly from true_type if the
-corresponding condition is true, otherwise from false_type
-where its BaseCharacteristic shall be true_type if the
-corresponding condition is true, otherwise false_type.
+
+
      
+Effects: Initializes c with std::move(q.c).
+
      
+
 
      
-
      4. 
-
    4. 
+
+
      
+For each of the following constructors,
+if uses_allocator<container_type, Alloc>::value is false,
+then the constructor shall not participate in overload resolution.
+
      
+
+
      template <class Alloc> 
+  explicit queue(const Alloc& a);
+
      
+
+
      
+
 
      
-Change 20.6.5 [meta.rel]/2 as indicated:
+Effects: Initializes c with a.
 
      
 
-
      
-Each of these templates shall be a BinaryTypeTrait (20.6.1),
-publicly derived directly or indirectly from true_type if the
-corresponding condition is true, otherwise from false_type
-where its BaseCharacteristic shall be true_type if the
-corresponding condition is true, otherwise false_type.
 
      
-
      5. 
-
    
 
+
    template <class Alloc> 
+  queue(const container_type& cont, const Alloc& a);
+
    
+
+
    
 
+
    
+Effects: Initializes c with cont as the first
+argument and a as the second argument.
+
    
 
+
    
 
+
    template <class Alloc> 
+  queue(container_type&& cont, const Alloc& a);
+
    
 
+
    
 
-
    
-
    1115. va_copy missing from Standard macros table
    
-
    Section: C.2 [diff.library] Status: New
- Submitter: Miles Zhao Opened: 2009-05-23  Last modified: 2009-05-23
    
-
    View other active issues in [diff.library].
    
-
    View all other issues in [diff.library].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-In "Table 122 -- Standard macros" of C.2 [diff.library], which lists the 56 macros
-inherited from C library, va_copy seems to be missing. But in
-"Table 21 -- Header <cstdarg> synopsis" (18.10 [support.runtime]), there is.
+Effects: Initializes c with std::move(cont) as the
+first argument and a as the second argument.
 
    
 
+
    
+
+
    template <class Alloc> 
+  queue(queue&& q, const Alloc& a);
+
    
+
+
    
 
-
    Proposed resolution:
    
 
    
-Add va_copy to Table 122 -- Standard macros in C.2 [diff.library].
+Effects: Initializes c with std::move(q.c) as the
+first argument and a as the second argument.
 
    
 
+
    
 
+
    queue& operator=(queue&& q);
+
    
 
+
    
 
-
-
    
-
    1116. Literal constructors for tuple
    
-
    Section: 20.5.2 [tuple.tuple] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-05-24
    
-
    View all other issues in [tuple.tuple].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-It is not currently possible to construct tuple literal values,
-even if the elements are all literal types.  This is because parameters
-are passed to constructor by reference.
-
    
-
    
-An alternative would be to pass all constructor arguments by value, where it
-is known that *all* elements are literal types.  This can be determined with
-concepts, although note that the negative constraint really requires
-factoring out a separate concept, as there is no way to provide an 'any of
-these fails' constraint inline.
+Effects: Assigns c with std::move(q.c).
 
    
+
 
    
-Note that we will have similar issues with pair (and
-tuple constructors from pair) although I am steering
-clear of that class while other constructor-related issues settle.
+Returns: *this.
 
    
 
+
    
+
+
+
+
    
 
-
    Proposed resolution:
    
 
    
-Ammend the tuple class template declaration in 20.5.2 [tuple.tuple] as
-follows
+Add to 23.3.5.2.1 [priqueue.cons]:
 
    
 
 
    
+
+
    priority_queue(priority_queue&& q);
+
    
+
+
    
+
 
    
-Add the following concept:
+Effects: Initializes c with std::move(q.c) and
+initializes comp with std::move(q.comp).
 
    
 
-
    auto concept AllLiteral< typename ... Types > {
-  requires LiteralType<Types>...;
-}
-
    
+
    
 
 
    
-ammend the constructor 
+For each of the following constructors,
+if uses_allocator<container_type, Alloc>::value is false,
+then the constructor shall not participate in overload resolution.
 
    
 
-
    template <class... UTypes>
-  requires AllLiteral<Types...>
-        && Constructible<Types, UTypes>...
-  explicit tuple(UTypes...);
+
    template <class Alloc>
+  explicit priority_queue(const Alloc& a);
+
    
 
-template <class... UTypes>
-  requires !AllLiteral<Types...>
-        && Constructible<Types, UTypes&&>...
-  explicit tuple(UTypes&&...);
-
    
+
    
 
 
    
-ammend the constructor
+Effects: Initializes c with a and value-initializes comp.
 
    
 
-
    template <class... UTypes>
-  requires AllLiteral<Types...>
-        && Constructible<Types, UTypes>...
-  tuple(tuple<UTypes...>);
+
    
 
-template <class... UTypes>
-  requires !AllLiteral<Types...>
-        && Constructible<Types, const UTypes&>...
-  tuple(const tuple<UTypes...>&);
-
    
+
    template <class Alloc>
+  priority_queue(const Compare& compare, const Alloc& a);
+
    
 
-
    
+
    
 
 
    
-Update the same signatures in 20.5.2.1 [tuple.cnstr], paras 3 and 5.
+Effects: Initializes c with a and initializes comp
+with compare.
 
    
 
+
    
 
+
    template <class Alloc>
+  priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
+
    
 
+
    
 
-
-
    
-
    1117. tuple copy constructor
    
-
    Section: 20.5.2.1 [tuple.cnstr] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-05-30
    
-
    View other active issues in [tuple.cnstr].
    
-
    View all other issues in [tuple.cnstr].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-The copy constructor for the tuple template is constrained.  This seems an
-unusual strategy, as the copy constructor will be implicitly deleted if the
-constraints are not met.  This is exactly the same effect as requesting an
-=default; constructor.  The advantage of the latter is that it retains
-triviality, and provides support for tuples as literal types if issue
-1116 is also accepted.
+Effects: Initializes c with cont as the first argument
+and a as the second argument,
+and initializes comp with compare.
 
    
+
+
    
+
+
    template <class Alloc>
+  priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
+
    
+
+
    
+
 
    
-Actually, it might be worth checking with core if a constrained copy
-constructor is treated as a constructor template, and as such does not
-suppress the implicit generation of the copy constructor which would hide
-the template in this case.
+Effects: Initializes c with std::move(cont) as 
+the first argument and a as the second argument,
+and initializes comp with compare.
 
    
 
-
    [
-2009-05-27 Daniel adds:
-]
    
+
    
 
+
    template <class Alloc>
+  priority_queue(priority_queue&& q, const Alloc& a);
+
    
 
 
    
-This would solve one half of the suggested changes in 801.
+
+
    
+Effects: Initializes c with std::move(q.c) as the
+first argument and a as the second argument, 
+and initializes comp with std::move(q.comp).
+
    
+
 
    
 
+
    priority_queue& operator=(priority_queue&& q);
+
    
+
+
    
 
-
    Proposed resolution:
    
 
    
-Change 20.5.2 [tuple.tuple] and 20.5.2.1 [tuple.cnstr] p4:
+Effects: Assigns c with std::move(q.c) and
+assigns comp with std::move(q.comp).
 
    
 
-
    requires CopyConstructible<Types>... tuple(const tuple&) = default;
-
    
+
    
+Returns: *this.
+
    
 
+
    
+
+
    
 
 
 
 
-
    
-
    1118. tuple query APIs do not support cv-qualification
    
-
    Section: 20.5.2.3 [tuple.helper] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-05-25
    
-
    View other active issues in [tuple.helper].
    
-
    View all other issues in [tuple.helper].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-The APIs tuple_size and tuple_element do not support
-cv-qualified tuples, pairs or arrays.
+Change 23.3.5.3.1 [stack.defn]:
 
    
+
+
    template <class T, class Container = deque<T> >
+class stack {
+public:
+  typedef typename Container::value_type      value_type;
+  typedef typename Container::reference       reference;
+  typedef typename Container::const_reference const_reference;
+  typedef typename Container::size_type       size_type;
+  typedef Container                           container_type;
+protected:
+  Container c;
+
+public:
+  explicit stack(const Container&);
+  explicit stack(Container&& = Container());
+  stack(stack&& s);
+  template <class Alloc> explicit stack(const Alloc&);
+  template <class Alloc> stack(const Container&, const Alloc&);
+  template <class Alloc> stack(Container&&, const Alloc&);
+  template <class Alloc> stack(stack&&, const Alloc&);
+  stack& operator=(stack&& s);
+
+  bool empty() const          { return c.empty(); }
+  ...
+};
+
    
+
 
    
-The most generic solution would be to supply partial specializations once
-for each cv-type in the tuple header.  However, requiring this header for
-cv-qualified pairs/arrays seems unhelpful.  The BSI editorial
-suggestion (UK-198/US-69,
-N2533)
-to merge tuple into <utility> would help with pair,
-but not array.  That might be resolved by making a dependency between the
-<array> header and <utility>, or simply recognising
-the dependency be fulfilled in a Remark.
+Add a new section after 23.3.5.3.1 [stack.defn], [stack.cons]:
 
    
 
-
    [
-2009-05-24 Daniel adds:
-]
    
+
    
+
    stack constructors [stack.cons]
    
 
+
    stack(stack&& s);
+
    
 
 
    
+
 
    
-All tuple_size templates with a base class need to derive publicly, e.g.
+Effects: Initializes c with std::move(s.c).
 
    
 
-
    template <IdentityOf T> class tuple_size< const T > :
-   public tuple_size<T> {};
-
    
+
    
 
 
    
-The same applies to the tuple_element class hierarchies.
+For each of the following constructors,
+if uses_allocator<container_type, Alloc>::value is false,
+then the constructor shall not participate in overload resolution.
 
    
+
+
    template <class Alloc> 
+  explicit stack(const Alloc& a);
+
    
+
+
    
+
 
    
-What is actually meant with the comment
+Effects: Initializes c with a.
 
    
-
    
-this solution relies on 'metafunction forwarding' to inherit the
-nested typename type
+
 
    
+
+
    template <class Alloc> 
+  stack(const container_type& cont, const Alloc& a);
+
    
+
+
    
+
 
    
-?
+Effects: Initializes c with cont as the
+first argument and a as the second argument.
 
    
+
+
    
+
+
    template <class Alloc> 
+  stack(container_type&& cont, const Alloc& a);
+
    
+
+
    
+
 
    
-I ask, because all base classes are currently unconstrained and their
-instantiation is invalid in the constrained context of the tuple_element partial
-template specializations.
+Effects: Initializes c with std::move(cont) as the
+first argument and a as the second argument.
 
    
-
    
 
-
    [
-2009-05-24 Alisdair adds:
-]
    
+
    
 
+
    template <class Alloc> 
+  stack(stack&& s, const Alloc& a);
+
    
 
 
    
+
 
    
-I think a better solution might be to ask Pete editorially to change all
-declarations of tupling APIs to use the struct specifier instead of class.
+Effects: Initializes c with std::move(s.c) as the
+first argument and a as the second argument.
 
    
+
+
    
+
+
    stack& operator=(stack&& s);
+
    
+
+
    
+
 
    
-"metafunction forwarding" refers to the MPL metafunction protocol, where a
-metafunction result is declared as a nested typedef with the name "type",
-allowing metafunctions to be chained by means of inheritance.  It is a
-neater syntax than repeatedly declaring a typedef, and inheritance syntax is
-slightly nicer when it comes to additional typename keywords.
+Effects: Assigns c with std::move(s.c).
 
    
+
 
    
-The constrained template with an unconstrained base is a good observation
-though.
+Returns: *this.
 
    
+
+
    
+
 
    
 
 
 
-
    Proposed resolution:
    
+
+
+
+
    
+
    1197. Can unordered containers have bucket_count() == 0?
    
+
    Section: 23.2.5 [unord.req] Status: New
+ Submitter: Howard Hinnant Opened: 2009-08-24  Last modified: 2009-09-03
    
+
    View other active issues in [unord.req].
    
+
    View all other issues in [unord.req].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Add to 20.5.1 [tuple.general] p2 (Header <tuple> synopsis)
+Table 97 "Unordered associative container requirements" in
+23.2.5 [unord.req] says:
 
    
 
-
    // 20.5.2.3, tuple helper classes:
-template <IdentityOf T> class tuple_size; // undefined
-template <IdentityOf T> class tuple_size< const T > : tuple_size<T> {};
-template <IdentityOf T> class tuple_size< volatile T > : tuple_size<T> {};
-template <IdentityOf T> class tuple_size< const volatile T > : tuple_size<T> {};
+
    
+
+
 
-template <VariableType... Types> class tuple_size<tuple<Types...> >;
+
+
+
+
+
+
 
-template <size_t I, IdentityOf T> class tuple_element; // undefined
-template <size_t I, IdentityOf T> class tuple_element<I, const T>;
-template <size_t I, IdentityOf T> class tuple_element<I, volatile T>;
-template <size_t I, IdentityOf T> class tuple_element<I, const volatile T>;
+
+
+
+
+
+
 
-template <size_t I, VariableType... Types>
-  requires True<(I < sizeof...(Types))> class tuple_element<I, tuple<Types...> >;
-
+
    Table 97 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    b.bucket(k)size_typeReturns the index of the bucket in which elements with keys 
+equivalent to k would be found, 
+if any such element existed. 
+Post: the return value shall be 
+in the range [0, 
+b.bucket_count()).Constant
    
+
    
 
 
    
-Add to 20.5.2.3 [tuple.helper]
+What should b.bucket(k) return if b.bucket_count() == 0?
 
    
-
    [
-(note that this solution relies on 'metafunction forwarding' to inherit the
-nested typename type)
-]
    
-
 
-
    template <class... Types>
-class tuple_size<tuple<Types...> >
-  : public integral_constant<size_t, sizeof...(Types)> { };
-
-template <size_t I, class... Types>
-requires True<(I < sizeof...(Types))>
-class tuple_element<I, tuple<Types...> > {
-public:
-  typedef TI type;
-};
+
    
+I believe allowing b.bucket_count() == 0 is important.  It is a
+very reasonable post-condition of the default constructor, or of a moved-from
+container.
+
    
 
-template <size_t I, IdentityOf T>
-  class tuple_element<I, const T> : add_const<tuple_element<I,T>> {};
+
    
+I can think of several reasonable results from b.bucket(k) when
+b.bucket_count() == 0:
+
    
 
-template <size_t I, IdentityOf T>
-  class tuple_element<I, volatile T> : add_volatile<tuple_element<I,T>> {};
+
      
+
    1. 
+Return 0.
+
      2. 
+
    2. 
+Return numeric_limits<size_type>::max().
+
      3. 
+
    3. 
+Throw a domain_error.
+
      4. 
+
    4. 
+Precondition: b.bucket_count() != 0.
+
      5. 
+
    
 
-template <size_t I, IdentityOf T>
-  class tuple_element<I, const volatile T> : add_cv<tuple_element<I,T>> {};
-
    
+
    [
+2009-08-26 Daniel adds:
+]
    
 
 
+
    
+
    
+A forth choice would be to add the pre-condition "b.bucket_count() != 0"
+and thus imply undefined behavior if this is violated.
+
    
 
+
    [
+Howard:  I like this option too, added to the list.
+]
    
 
 
-
    
-
    1119. tuple query APIs do not support references
    
-
    Section: 20.5.2.3 [tuple.helper] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-05-24
    
-
    View other active issues in [tuple.helper].
    
-
    View all other issues in [tuple.helper].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-The tuple query APIs tuple_size and
-tuple_element do not support references-to-tuples.  This can be
-annoying when a template deduced a parameter type to be a reference,
-which must be explicitly stripped with remove_reference before calling
-these APIs.
+Further on here my own favorite solution (rationale see below):
 
    
+
+
    Suggested resolution:
    
+
 
    
-I am not proposing a resolution at this point, as there is a
-combinatorial explosion with lvalue/rvalue references and
-cv-qualification (see previous issue) that suggests some higher
-refactoring is in order.  This might be something to kick back over to
-Core/Evolution.
+[Rationale: I suggest to follow choice (1). The main reason is
+that all associative container functions which take a key argument,
+are basically free of pre-conditions and non-disrupting, therefore
+excluding choices (3) and (4). Option (2) seems a bit unexpected
+to me. It would be more natural, if several similar functions
+would exist which would also justify the existence of a symbolic
+constant like npos for this situation. The value 0 is both simple
+and consistent, it has exactly the same role as a past-the-end
+iterator value. A typical use-case is:
 
    
+
+
    size_type pos = m.bucket(key);
+if (pos != m.bucket_count()) {
+ ...
+} else {
+ ...
+}
+
    
+
+
    — end Rationale]
    
+
 
    
-Note that we have the same problem in numeric_limits.
+- Change Table 97 in 23.2.5 [unord.req] as follows (Row b.bucket(k), Column "Assertion/..."):
 
    
 
+
    
+
+
 
-
    Proposed resolution:
    
-
+
+
+
+
+
+
 
+
+
+
+
+
+
 
+
    Table 97 — Unordered associative container requirements
+(in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-conditionComplexity
    b.bucket(k)size_typeReturns the index of the bucket in which elements with keys 
+equivalent to k would be found, 
+if any such element existed. 
+Post: if b.bucket_count() != 0, the return value shall be 
+in the range [0, 
+b.bucket_count()), otherwise 0.Constant
    
+
    
 
+
    
 
-
    
-
    1120. New type trait - remove_all
    
-
    Section: 20.6 [meta] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-05-24
    
-
    View other active issues in [meta].
    
-
    View all other issues in [meta].
    
-
    View all issues with New status.
    
-
    Discussion:
    
-
    
-Sometimes it is necessary to remove all qualifiers from a type before
-passing on to a further API.  A good example would be calling the
-tuple query APIs tuple_size or tuple_element
-with a deduced type inside a function template.  If the deduced type is
-cv-qualified or a reference then the call will fail.  The solution is to
-chain calls to
-remove_cv<remove_reference<T>::type>::type, and
-note that the order matters.
-
    
-
    
-Suggest it would be helpful to add a new type trait,
-remove_all, that removes all top-level qualifiers from a type
-i.e. cv-qualification and any references.  Define the term in such a way
-that if additional qualifiers are added to the language, then
-remove_all is defined as stripping those as well.
-
    
 
 
 
    Proposed resolution:
    
+
    
+
    
 
 
 
 
 
 
    
-
    1121. Support for multiple arguments
    
-
    Section: 20.4.2 [ratio.arithmetic] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-25  Last modified: 2009-05-25
    
-
    View all other issues in [ratio.arithmetic].
    
+
    1198. Container adaptor swap: member or non-member?
    
+
    Section: 23.3.5 [container.adaptors] Status: New
+ Submitter: Pablo Halpern Opened: 2009-08-26  Last modified: 2009-09-30
    
+
    View other active issues in [container.adaptors].
    
+
    View all other issues in [container.adaptors].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-Both add and multiply could sensibly be called with more than two arguments.
-The variadic template facility makes such declarations simple, and is likely
-to be frequently wrapped by end users if we do not supply the variant
-ourselves.
+Under 23.3.5 [container.adaptors] of
+N2914
+the member function of swap of queue and stack call:
 
    
+
+
    swap(c, q.c);
+
    
+
 
    
-We deliberately ignore divide at this point as it is not transitive.
-Likewise, subtract places special meaning on the first argument so I do not
-suggest extending that immediately.  Both could be supported with analogous
-wording to that for add/multiply below.
+But under 23.3.5 [container.adaptors] of
+N2723
+these members are specified to call:
+
    
+
+
    c.swap(q.c);
+
    
+
+
    
+Neither draft specifies the semantics of member swap for
+priority_queue though it is declared.
 
    
+
 
    
-Note that the proposed resolution is potentially incompatible with that
-proposed for 921, although the addition of the typedef to ratio would be
-equally useful.
+Although the distinction between member swap and non-member
+swap is not important when these adaptors are adapting standard
+containers, it may be important for user-defined containers.
+
    
+
    
+We (Pablo and Howard) feel that
+it is more likely for a user-defined container to support a namespace scope
+swap than a member swap, and therefore these adaptors
+should use the container's namespace scope swap.
 
    
 
+
    [
+2009-09-30 Daniel adds:
+]
    
+
+
+
    
+The outcome of this issue should be considered with the outcome of 774 both in style and in content (e.g. 774 bullet 9
+suggests to define the semantic of void
+priority_queue::swap(priority_queue&) in terms of the member
+swap of the container).
+
    
+
+
 
 
    Proposed resolution:
    
 
    [
-note that this wording relies on 'metafunction forwarding' as described by
-Boost MPL
+Changes written with respect to
+N2723.
 ]
    
 
 
 
    
-20.4 [ratio] p3 synopsis: change
+Change 23.3.5.1.1 [queue.defn]:
 
    
 
-
    // ratio arithmetic
-template <class R1, class R2, class ... RList> struct ratio_add;
-template <class R1, class R2> struct ratio_subtract;
-template <class R1, class R2, class ... RList> struct ratio_multiply;
-template <class R1, class R2> struct ratio_divide;
+
    template <class T, class Container = deque<T> > 
+class queue {
+   ...
+   void swap(queue&& q) { using std::swap;
+                          c.swap(c, q.c); }
+   ...
+};
 
    
 
 
    
-20.4.2 [ratio.arithmetic] p1: change
+Change 23.3.5.2 [priority.queue]:
 
    
 
-
    template <class R1, class R2, class ... RList> struct ratio_add
-  : ratio_add< R1, ratio_add<R2, RList...>> {
-};
-
-template <class R1, class R2> struct ratio_add<R1, R2> {
-  typedef see below type;
+
    template <class T, class Container = vector<T>, 
+          class Compare = less<typename Container::value_type> > 
+class priority_queue { 
+    ...
+    void swap(priority_queue&& q); { using std::swap;
+                                     swap(c, q.c);
+                                     swap(comp, q.comp); }
+    ...
 };
 
    
 
-
 
    
-20.4.2 [ratio.arithmetic] p3: change
+Change 23.3.5.3.1 [stack.defn]:
 
    
 
-
    template <class R1, class R2, class ... RList> struct ratio_multiply
-  : ratio_multiply< R1, ratio_ multiply <R2, RList...>> {
-};
-
-template <class R1, class R2> struct ratio_ multiply<R1, R2> {
-  typedef see below type;
+
    template <class T, class Container = deque<T> > 
+class stack {
+   ...
+   void swap(stack&& s) { using std::swap;
+                          c.swap(c, s.c); }
+   ...
 };
 
    
 
@@ -28116,221 +23829,198 @@ template <class R1, class R2> struct ratio_ multiply<R1, R2>
-
    1122. Ratio values should be constexpr
    
-
    Section: 20.4.1 [ratio.ratio] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-25  Last modified: 2009-05-25
    
-
    View other active issues in [ratio.ratio].
    
-
    View all other issues in [ratio.ratio].
    
+
    1199. Missing extended copy constructor in container adaptors
    
+
    Section: 23.3.5 [container.adaptors] Status: New
+ Submitter: Pablo Halpern Opened: 2009-08-26  Last modified: 2009-08-31
    
+
    View other active issues in [container.adaptors].
    
+
    View all other issues in [container.adaptors].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-The values num and den in the ratio template
-should be declared constexpr.
+queue has a constructor:
 
    
 
+
    template <class Alloc>
+  queue(queue&&, const Alloc&);
+
    
 
-
    Proposed resolution:
    
 
    
-20.4.1 [ratio.ratio]
+but it is missing a corresponding constructor:
 
    
 
-
    namespace std {
-  template <intmax_t N, intmax_t D = 1>
-  class ratio {
-  public:
-    static constexpr intmax_t num;
-    static constexpr intmax_t den;
-  };
-}
+
    template <class Alloc>
+  queue(const queue&, const Alloc&);
 
    
 
-
-
-
-
-
-
    
-
    1123. no requirement that standard streams be flushed
    
-
    Section: 27.5.2.1.6 [ios::Init] Status: New
- Submitter: James Kanze Opened: 2009-05-14  Last modified: 2009-05-30
    
-
    View all other issues in [ios::Init].
    
-
    View all issues with New status.
    
-
    Discussion:
    
-
    
-As currently formulated, the standard doesn't require that there 
-is ever a flush of cout, etc.  (This implies, for example, that 
-the classical hello, world program may have no output.)  In the 
-current draft
-(N2798),
-there is a requirement that the objects 
-be constructed before main, and before the dynamic 
-initialization of any non-local objects defined after the 
-inclusion of <iostream> in the same translation unit.  The only 
-requirement that I can find concerning flushing, however, is in 
-27.5.2.1.6 [ios::Init], where the destructor of the last 
-std::ios_base::Init object flushes.  But there is, as far as I 
-can see, no guarantee that such an object ever exists. 
-
    
-
    
-Also, the wording in  [iostreams.objects] says that:
-
    
-
    
-The objects 
-are constructed and the associations are established at some 
-time prior to or during the first time an object of class 
-ios_base::Init is constructed, and in any case before the body 
-of main begins execution.
-
    
-
    
-In 27.5.2.1.6 [ios::Init], however, as an 
-effect of the constructor, it says that
-
    
-
    
-If init_cnt is zero, 
-the function stores the value one in init_cnt, then constructs 
-and initializes the objects cin, cout, cerr, clog 
-wcin, wcout, wcerr, and wclog"
-
    
-
 
    
-which seems to forbid earlier 
-construction. 
+The same is true of priority_queue, and stack.  This
+"extended copy constructor" is needed for consistency and to ensure that the
+user of a container adaptor can always specify the allocator for his adaptor.
 
    
 
-
    
-(Note that with these changes, the exposition only "static 
-int init_cnt" in ios_base::Init can be dropped.) 
-
    
-
    
-Of course, a determined programmer can still inhibit the 
-flush with things like: 
-
    
-
    new std::ios_base::Init ;       //  never deleted 
-
    
-
    
-or (in a function): 
-
    
-
    std::ios_base::Init ensureConstruction ; 
-//  ... 
-exit( EXIT_SUCCESS ) ; 
-
    
-
    
-Perhaps some words somewhere to the effect that all 
-std::ios_base::Init objects should have static lifetime 
-would be in order. 
-
    
 
 
 
    Proposed resolution:
    
-
    
-Change 27.4 [iostream.objects]/2:
-
    
+
    [
+This resolution has been harmonized with the proposed resolution to issue
+1194
+]
    
 
-
    
--2- The objects are constructed and the associations are established at
-some time prior to or during the first time an object of class
-ios_base::Init is constructed, and in any case before the body
-of main begins execution.292 The objects are not destroyed
-during program execution.293
-If a translation unit includes
-<iostream> or explicitly constructs an
-ios_base::Init object, these stream objects shall be
-constructed before dynamic initialization of non-local objects defined
-later in that translation unit.
-The results of including <iostream> in a translation
-unit shall be as if <iostream> defined an instance of
-ios_base::Init with static lifetime. Similarly, the entire
-program shall behave as if there were at least one instance of
-ios_base::Init with static lifetime.
-
    
 
-
    
-Change 27.5.2.1.6 [ios::Init]/3:
-
    
+
    Change 23.3.5.1.1 [queue.defn], p1:
    
 
-
    
-
    Init();
-
    
-
    
--3- Effects: Constructs an object of class Init. 
-If init_cnt is zero, the function stores the value one in
-init_cnt, then constructs and initializes the objects
-cin, cout, cerr, clog (27.4.1),
-wcin, wcout, wcerr, and wclog
-(27.4.2). In any case, the function then adds one to the value stored in
-init_cnt.
-Constructs and initializes the objects cin, cout,
-cerr, clog, wcin, wcout,
-wcerr and wclog if they have not already been
-constructed and initialized.
-
    
-
    
+
    template <class T, class Container = deque<T> >
+class queue {
+public:
+  typedef typename Container::value_type      value_type;
+  typedef typename Container::reference       reference;
+  typedef typename Container::const_reference const_reference;
+  typedef typename Container::size_type       size_type;
+  typedef Container                           container_type;
+protected:
+  Container c;
+
+public:
+  explicit queue(const Container&);
+  explicit queue(Container&& = Container());
+  queue(queue&& q);
+
+  template <class Alloc> explicit queue(const Alloc&);
+  template <class Alloc> queue(const Container&, const Alloc&);
+  template <class Alloc> queue(Container&&, const Alloc&);
+  template <class Alloc> queue(const queue&, const Alloc&);
+  template <class Alloc> queue(queue&&, const Alloc&);
+  queue& operator=(queue&& q);
+
+  bool empty() const          { return c.empty(); }
+  ...
+};
+
    
 
 
    
-Change 27.5.2.1.6 [ios::Init]/4:
+To the new section  [queue.cons], introduced
+in 1194, add:
 
    
 
 
    
-
    ~Init();
+
+
    template <class Alloc> 
+  queue(const queue& q, const Alloc& a);
 
    
-
    
--4- Effects: Destroys an object of class Init.
-The function subtracts one from the value stored in init_cnt and,
-if the resulting stored value is one,
-If there are no other instances of the class still in
-existance,
-calls cout.flush(),
-cerr.flush(), clog.flush(), wcout.flush(),
-wcerr.flush(), wclog.flush().
-
    
-
    
 
+
    
+Effects: Initializes c with q.c as the
+first argument and a as the second argument.
+
    
 
+
    
 
+
    Change 23.3.5.2 [priority.queue] as follows (I've an included an editorial change to
+  move the poorly-placed move-assignment operator):
    
 
+
    template <class T, class Container = vector<T>,
+          class Compare = less<typename Container::value_type> >
+class priority_queue {
+public:
+  typedef typename Container::value_type      value_type;
+  typedef typename Container::reference       reference;
+  typedef typename Container::const_reference const_reference;
+  typedef typename Container::size_type       size_type;
+  typedef          Container                  container_type;
+protected:
+  Container c;
+  Compare comp;
 
+public:
+  priority_queue(const Compare& x, const Container&);
+  explicit priority_queue(const Compare& x = Compare(), Container&& = Container());
+  template <class InputIterator>
+    priority_queue(InputIterator first, InputIterator last,
+                   const Compare& x, const Container&);
+  template <class InputIterator>
+    priority_queue(InputIterator first, InputIterator last,
+                   const Compare& x = Compare(), Container&& = Container());
+  priority_queue(priority_queue&&);
+  priority_queue& operator=(priority_queue&&);
+  template <class Alloc> explicit priority_queue(const Alloc&);
+  template <class Alloc> priority_queue(const Compare&, const Alloc&);
+  template <class Alloc> priority_queue(const Compare&,
+                                        const Container&, const Alloc&);
+  template <class Alloc> priority_queue(const Compare&,
+                                        Container&&, const Alloc&);
+  template <class Alloc> priority_queue(const priority_queue&, const Alloc&);
+  template <class Alloc> priority_queue(priority_queue&&, const Alloc&);
+
+  priority_queue& operator=(priority_queue&&);
+  ...
+};
+
    
 
-
    
-
    1125. ostream_iterator does not work with movable types
    
-
    Section: 24.6.2.2 [ostream.iterator.ops] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-05-30
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-ostream_iterator has not been updated to support moveable types, in a
-similar manner to the insert iterators.
-Note that this is not a problem for ostreambuf_iterator, as the types it is
-restricted to dealing with do not support extra-efficient moving.
+Add to 23.3.5.2.1 [priqueue.cons]:
 
    
 
+
    
+
+
    template <class Alloc>
+  explicit priority_queue(const priority_queue& q, const Alloc& a);
+
    
+
+
    
+Effects: Initializes c with q.c as the
+first argument and a as the second argument, 
+and initializes comp with q.comp.
+
    
+
+
    
 
-
    Proposed resolution:
    
 
    
-Add second operator= overload to class template ostream_iterator
-in 24.6.2 [ostream.iterator], para 2:
+Change 23.3.5.3.1 [stack.defn]:
 
    
 
-
    ostream_iterator<T,charT,traits>& operator=(const T& value);
-ostream_iterator<T,charT,traits>& operator=(T&& value);
+
    template <class T, class Container = deque<T> >
+class stack {
+public:
+  typedef typename Container::value_type      value_type;
+  typedef typename Container::reference       reference;
+  typedef typename Container::const_reference const_reference;
+  typedef typename Container::size_type       size_type;
+  typedef Container                           container_type;
+protected:
+  Container c;
+
+public:
+  explicit stack(const Container&);
+  explicit stack(Container&& = Container());
+  stack(stack&& s);
+
+  template <class Alloc> explicit stack(const Alloc&);
+  template <class Alloc> stack(const Container&, const Alloc&);
+  template <class Alloc> stack(Container&&, const Alloc&);
+  template <class Alloc> stack(const stack&, const Alloc&);
+  template <class Alloc> stack(stack&&, const Alloc&);
+  stack& operator=(stack&& s);
+
+  bool empty() const          { return c.empty(); }
+  ...
+};
 
    
 
 
    
-Add a new paragraph: in 24.6.2.2 [ostream.iterator.ops]:
+To the new section  [stack.cons], introduced
+in 1194, add:
 
    
 
 
    
-
    ostream_iterator& operator=(T&& value);
+
+
    template <class Alloc> 
+  stack(const stack& s, const Alloc& a);
 
    
-
    
-
    
--2- Effects:
-
    
-
    *out_stream << std::move(value);
-if(delim != 0)
-  *out_stream << delim;
-return (*this);
-
    
-
    
+
+
    
+Effects: Initializes c with s.c as the
+first argument and a as the second argument.
+
    
 
    
 
 
@@ -28339,1107 +24029,1170 @@ return (*this);
 
 
 
    
-
    1126. istreambuff_iterator::equal needs a const & parameter
    
-
    Section: 24.6.3.5 [istreambuf.iterator::equal] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-05-30
    
-
    View all other issues in [istreambuf.iterator::equal].
    
+
    1200. "surprising" char_traits<T>::int_type requirements
    
+
    Section: 21.2.2 [char.traits.typedefs] Status: New
+ Submitter: Sean Hunt Opened: 2009-09-03  Last modified: 2009-10-28
    
+
    View all other issues in [char.traits.typedefs].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-The equal member function of istreambuf_iterator is
-declared const, but takes its argument by non-const reference.
+The footnote for int_type in 21.2.2 [char.traits.typedefs] says that
 
    
+
+
    
+If eof()
+can be held in char_type then some iostreams implementations may give
+surprising results.
+
    
+
 
    
-This is not compatible with the operator== free function overload, which is
-defined in terms of calling equal yet takes both arguments by reference to
-const.
+This implies that int_type should be a superset of
+char_type. However, the requirements for char16_t and char32_t define
+int_type to be equal to int_least16_t and int_least32_t respectively.
+int_least16_t is likely to be the same size as char_16_t, which may lead
+to surprising behavior, even if eof() is not a valid UTF-16 code unit.
+The standard should not prescribe surprising behavior, especially
+without saying what it is (it's apparently not undefined, just
+surprising). The same applies for 32-bit types.
+
    
+
+
    
+I personally recommend that behavior be undefined if eof() is a member
+of char_type, and another type be chosen for int_type (my personal
+favorite has always been a struct {bool eof; char_type c;}).
+Alternatively, the exact results of such a situation should be defined,
+at least so far that I/O could be conducted on these types as long as
+the code units remain valid. Note that the argument that no one streams
+char16_t or char32_t is not really valid as it would be perfectly
+reasonable to use a basic_stringstream in conjunction with UTF character
+types.
 
    
 
 
    [
-The proposed wording is consistent with 110 with status TC1.
+2009-10-28 Ganesh provides two possible resolutions and expresses a preference
+for the second:
 ]
    
 
 
+
    
+
      
+
    1. 
+
      
+Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
+
      
 
+
      
+The member eof() shall return an implementation-defined
+constant that cannot appear as a valid UTF-16 code unit
+UINT_LEAST16_MAX [Note: this value is guaranteed to
+be a permanently reserved UCS-2 code position if UINT_LEAST16_MAX ==
+0xFFFF and it's not a UCS-2 code position otherwise — end
+note].
+
      
 
-
      Proposed resolution:
      
 
      
-Ammend in both:
      
-24.6.3 [istreambuf.iterator]
      
-24.6.3.5 [istreambuf.iterator::equal]
      
+Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
 
      
 
-
      bool equal(const istreambuf_iterator& b) const;
-
      
+
      
+The member eof() shall return an implementation-defined constant that
+cannot appear as a Unicode code point
+
+UINT_LEAST32_MAX [Note: this value is guaranteed to be a
+permanently reserved UCS-4 code position if UINT_LEAST32_MAX ==
+0xFFFFFFFF and it's not a UCS-4 code position otherwise — end
+note].
+
      
+
      2. 
+
    2. 
+
      
+In 21.2.3.2 [char.traits.specializations.char16_t], in the
+definition of char_traits<char16_t> replace the definition of nested
+typedef int_type with:
+
      
 
+
      namespace std {
+  template<> struct char_traits<char16_t> {
+    typedef char16_t         char_type;
+    typedef uint_least16_t uint_fast16_t int_type;
+     ...
+
      
 
+
      
+Replace 21.2.3.2 [char.traits.specializations.char16_t] para 3 with:
+
      
 
+
      
+The member eof() shall return an implementation-defined
+constant that cannot appear as a valid UTF-16 code unit
+UINT_FAST16_MAX [Note: this value is guaranteed to
+be a permanently reserved UCS-2 code position if UINT_FAST16_MAX ==
+0xFFFF and it's not a UCS-2 code position otherwise — end
+note].
+
      
 
+
      
+In 21.2.3.3 [char.traits.specializations.char32_t], in the
+definition of char_traits<char32_t> replace the definition of nested
+typedef int_type with:
+
      
 
+
      namespace std {
+  template<> struct char_traits<char32_t> {
+    typedef char32_t         char_type;
+    typedef uint_least32_t uint_fast32_t int_type;
+     ...
+
      
 
-
      
-
      1129. istream(buf)_iterator should support literal sentinel value
      
-
      Section: 24.6.1.1 [istream.iterator.cons], 24.6.3 [istreambuf.iterator] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-30  Last modified: 2009-06-09
      
-
      View all issues with New status.
      
-
      Discussion:
      
 
      
-istream_iterator and istreambuf_iterator should support literal sentinel
-values.  The default constructor is frequently used to terminate ranges, and
-could easily be a literal value for istreambuf_iterator, and
-istream_iterator when iterating value types.  A little more work using a
-suitably sized/aligned char-array for storage (or an updated component like
-boost::optional proposed for TR2) would allow istream_iterator to support
-constexpr default constructor in all cases, although we might leave this
-tweak as a QoI issue.  Note that requiring constexpr be supported also
-allows us to place no-throw guarantees on this constructor too.
+Replace 21.2.3.3 [char.traits.specializations.char32_t] para 3 with:
 
      
 
-
      [
-2009-06-02 Daniel adds:
-]
      
+
      
+The member eof() shall return an implementation-defined constant that
+cannot appear as a Unicode code point
+
+UINT_FAST32_MAX [Note: this value is guaranteed to be a
+permanently reserved UCS-4 code position if UINT_FAST32_MAX ==
+0xFFFFFFFF and it's not a UCS-4 code position otherwise — end
+note].
+
      
+
      3. 
+
    
+
    
 
 
-
    
-
    
-I agree with the usefulness of the issue suggestion, but we need
-to ensure that istream_iterator can satisfy be literal if needed.
-Currently this is not clear, because 24.6.1 [istream.iterator]/3 declares
-a copy constructor and a destructor and explains their semantic in
-24.6.1.1 [istream.iterator.cons]/3+4.
-
    
+
+
    Proposed resolution:
    
 
    
-The prototype semantic specification is ok (although it seems
-somewhat redundant to me, because the semantic doesn't say
-anything interesting in both cases), but for support of trivial class
-types we also need a trivial copy constructor and destructor as of
-9 [class]/6. The current non-informative specification of these
-two special members suggests to remove their explicit declaration
-in the class and add explicit wording that says that if T is
-trivial a default constructed iterator is also literal, alternatively it
-would be possible to mark both as defaulted and add explicit
-(memberwise) wording that guarantees that they are trivial.
 
    
+
+
+
+
+
+
    
+
    1201. Do we always want to unwrap ref-wrappers in make_tuple
    
+
    Section: 20.5.2.4 [tuple.creation], 20.3.4 [pairs] Status: Tentatively NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-09-05  Last modified: 2009-10-26
    
+
    View all issues with Tentatively NAD Future status.
    
+
    Discussion:
    
 
    
-Btw.: I'm quite sure that the istreambuf_iterator additions to
-ensure triviality are not sufficient as suggested, because the
-library does not yet give general guarantees that a defaulted
-special member declaration makes this member also trivial.
-Note that e.g. the atomic types do give a general statement!
+Spotting a recent thread on the boost lists regarding collapsing
+optional representations in optional<optional<T>> instances, I wonder if
+we have some of the same issues with make_tuple, and now make_pair?
 
    
+
 
    
-Finally there is a wording issue: There does not exist something
-like a "literal constructor". The core language uses the term
-"constexpr constructor" for this.
+Essentially, if my generic code in my own library is handed a
+reference_wrapper by a user, and my library in turn delegates some logic
+to make_pair or make_tuple, then I am going to end up with a pair/tuple
+holding a real reference rather than the intended reference wrapper.
 
    
+
 
    
-Suggestion:
+There are two things as a library author I can do at this point:
 
    
-
      
+
+
        
 
      1. 
-
        
-Change 24.6.1 [istream.iterator]/3 as indicated:
-
        
-
        constexpr istream_iterator();
-istream_iterator(istream_type& s);
-istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
-~istream_iterator() = default;
-
        
+document my library also has the same reference-wrapper behaviour as
+std::make_tuple
 
        2. 
 
      2. 
+roll my own make_tuple that does not unwrap rereferences, a lost
+opportunity to re-use the standard library.
+
        3. 
+
      
+
 
      
-Change 24.6.1.1 [istream.iterator.cons]/1 as indicated:
+(There may be some metaprogramming approaches my library can use to wrap
+the make_tuple call, but all will be significantly more complex than
+simply implementing a simplified make_tuple.)
 
      
-
      constexpr istream_iterator();
-
      
+
+
      
+Now I don't propose we lose this library facility, I think unwrapping
+references will be the common behaviour.  However, we might want to
+consider adding another overload that does nothing special with
+ref-wrappers.  Note that we already have a second overload of make_tuple
+in the library, called tie.
+
      
+
+
      [
+2009-09-30 Daniel adds:
+]
      
+
+
 
      
--1- Effects: Constructs the end-of-stream iterator. If T is a literal type,
-then this constructor shall be a constexpr constructor.
-
      
-
      
-
-
    1. 
 
      
-Change 24.6.1.1 [istream.iterator.cons]/3 as indicated:
+I suggest to change the currently proposed paragraph for
+make_simple_pair
 
      
-
      istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
+
+
      template<typename... Types>
+  pair<typename decay<Types>::type...> make_simple_pair(Types&&... t);
 
      
 
      
--3- Effects: Constructs a copy of x. If T is a literal type, then
-this constructor shall be a trivial copy constructor.
+
      
+Type requirements: sizeof...(Types) == 2.
+Remarks: The program shall be ill-formed, if
+sizeof...(Types) != 2.
+
      
+
      
+...
+
      
 
      
 
      
-
      2. 
-
    2. 
+
 
      
-Change 24.6.1.1 [istream.iterator.cons]/4 as indicated:
+or alternatively (but with a slightly different semantic):
 
      
 
-
      ~istream_iterator() = default;
-
      
 
      
--4- Effects: The iterator is destroyed. If T is a literal type, then
-this destructor shall be a trivial
-destructor.
+
      
+Remarks: If sizeof...(Types) != 2, this function shall not
+participate in overload resolution.
 
      
 
      
-
      3. 
-
    3. 
+
 
      
-Change 24.6.3 [istreambuf.iterator] before p. 1 as indicated:
+to follow a currently introduced style and because the library does
+not have yet a specific "Type requirements" element. If such thing
+would be considered as useful this should be done as a separate
+issue. Given the increasing complexity of either of these wordings
+it might be preferable to use the normal two-argument-declaration
+style again in either of the following ways:
 
      
 
-
      constexpr istreambuf_iterator() throw();
-istreambuf_iterator(const istreambuf_iterator&)  throw() = default;
-~istreambuf_iterator()  throw() = default;
-
      
+
        
+
      1. 
+
        template<class T1, class T2>
+pair<typename decay<T1>::type, typename decay<T2>::type>
+make_simple_pair(T1&& t1, T2&& t2);
+
        
 
        2. 
 
      2. 
-
        
-Change 24.6.3 [istreambuf.iterator]/1 as indicated:
-
        
+
        template<class T1, class T2>
+pair<V1, V2> make_simple_pair(T1&& t1, T2&& t2);
+
        
 
        
-[..] The default constructor istreambuf_iterator() and the constructor
-istreambuf_iterator(0) both
-construct an end of stream iterator object suitable for use as an
-end-of-range. All
-specializations of istreambuf_iterator shall have a trivial copy
-constructor, a constexpr default
-constructor and a trivial destructor.
+Let V1 be typename decay<T1>::type and V2 be
+typename decay<T2>::type.
 
        
 
        3. 
 
      
+
 
    
 
+
    [
+2009-10 post-Santa Cruz:
+]
    
 
-
    Proposed resolution:
    
-
    
-24.6.1 [istream.iterator] para 3
-
    
 
-
    constexpr istream_iterator();
-
    
+
    
+Mark as Tentatively NAD Future.
+
    
 
+
+
+
    Proposed resolution:
    
 
    
-24.6.1.1 [istream.iterator.cons]
+Add the following function to 20.3.4 [pairs] and signature in
+appropriate synopses:
 
    
 
-
    constexpr istream_iterator();
+
    template<typename... Types>
+  pair<typename decay<Types>::type...> make_simple_pair(Types&&... t);
 
    
 
    
--1- Effects: Constructs the end-of-stream iterator.
-If T is a literal type, then this constructor shall
-be a literal constructor.
+
    
+Type requirements: sizeof...(Types) == 2.
+
    
+
    
+Returns: pair<typename decay<Types>::type...>(std::forward<Types>(t)...).
+
    
 
    
 
    
 
+
    [
+Draughting note: I chose a variadic representation similar to make_tuple
+rather than naming both types as it is easier to read through the
+clutter of metaprogramming this way.  Given there are exactly two
+elements, the committee may prefer to draught with two explicit template
+type parameters instead
+]
    
+
+
 
    
-24.6.3 [istreambuf.iterator]
+Add the following function to 20.5.2.4 [tuple.creation] and
+signature in appropriate synopses:
 
    
 
-
    constexpr istreambuf_iterator() throw();
-
    
-
+
    template<typename... Types>
+  tuple<typename decay<Types>::type...> make_simple_tuple(Types&&... t);
+
    
+
    
+
    
+Returns: tuple<typename decay<Types>::type...>(std::forward<Types>(t)...).
+
    
+
    
+
    
 
 
 
 
 
 
    
-
    1130. copy_exception name misleading
    
-
    Section: 18.8.5 [propagation] Status: New
- Submitter: Peter Dimov Opened: 2009-05-13  Last modified: 2009-06-02
    
-
    View other active issues in [propagation].
    
-
    View all other issues in [propagation].
    
+
    1202. integral_constant needs a spring clean
    
+
    Section: 20.6.3 [meta.help] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-09-05  Last modified: 2009-09-06
    
+
    View all other issues in [meta.help].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-The naming of std::copy_exception misleads almost everyone
-(experts included!) to think that it is the function that copies an
-exception_ptr:
+The specification of integral_constant has been inherited
+essentially unchanged from TR1:
 
    
 
-
    exception_ptr p1 = current_exception();
-exception_ptr p2 = copy_exception( p1 );
+
    template <class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T,v> type;
+};
 
    
 
 
    
-But this is not at all what it does. The above actually creates an
-exception_ptr p2 that contains a copy of p1, not of
-the exception to which p1 refers!
-
    
-
    
-This is, of course, all my fault; in my defence, I used copy_exception
-because I was unable to think of a better name.
-
    
-
    
-But I believe that, based on what we've seen so far, any other name would be better.
+In light of 0x language changes there are several things we might
+consider changing, notably the form of specification for value.
 
    
+
 
    
-Therefore, I propose copy_exception to be renamed to
-create_exception:
+The current form requires a static data member have storage allocated
+for it, where we could now implement without this using the new enum
+syntax:
 
    
 
-
    template<class E> exception_ptr create_exception(E e);
+
    template <class T, T v>
+struct integral_constant {
+  enum : T { value = v };
+  typedef T value_type;
+  typedef integral_constant type;
+};
 
    
 
 
    
-with the following explanatory paragraph after it:
+The effective difference between these two implementation is:
 
    
 
-
    
-Creates an exception_ptr that refers to a copy of e.
-
    
+
      
+
    1. 
+No requirement to allocate storage for data member (which we hope but do
+not guarantee compilers strip today)
+
      2. 
 
-
      [
-2009-05-13 Daniel adds:
-]
      
+
    2. 
+You can no longer take the address of the constant as
+&integral_constant<T,v>::value;
+
      3. 
+
    
 
+
    
+Also note the editorial change to drop the explicit qualification of
+integral_constant in the typedef type.  This makes it quite clear we
+mean the current instantiation, and cannot be mistaken for a recursive
+metaprogram.
+
    
 
-
    
 
    
-What about
+Even if we don't mandate this implementation, it would be nice to give
+vendors freedom under QoI to choose their preferred representation.
 
    
-
    make_exception_ptr
-
    
+
 
    
-in similarity to make_pair and make_tuple, make_error_code and
-make_error_condition, or make_shared? Or, if a stronger symmetry to
-current_exception is preferred:
+The other side of this issue is if we choose to retain the static
+constant form.  In that case we should go further and insist on
+constexpr, much like we did throughout numeric_limits:
 
    
 
-
    make_exception
+
    template <class T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  typedef T value_type;
+  typedef integral_constant type;
+};
 
    
+
 
    
-We have not a single create_* function in the library, it was always
-make_* used.
+[Footnote] It turns out constexpr is part of the Tentatively Ready
+resolution for 1019.  I don't want to interfere with that issue, but
+would like a new issue to consider if the fixed-base enum implementation
+should be allowed.
 
    
-
    
 
 
    [
-2009-05-13 Peter adds:
+2009-09-05 Daniel adds:
 ]
    
 
 
 
    
-make_exception_ptr works for me.
-
    
+
    
+I think that the suggested resolution is incomplete and
+may have some possible unwanted side-effects. To understand
+why, note that integral_constant is completely specified
+by code in 20.6.3 [meta.help]. While this is usually considered
+as a good thing, let me give a possible user-defined
+specialization that would break given the suggested changes:
+
    
 
-
    [
-2009-06-02 Thomas J. Gritzan adds:
-]
    
+
    enum NodeColor { Red, Black };
 
+std::integral_constant<NodeColor, Red> red;
+
    
 
-
    
 
    
-To avoid surprises and unwanted recursion, how about making a call to
-std::make_exception_ptr with an exception_ptr illegal?
+The reason why that breaks is due to the fact that
+current core language rules does only allow integral
+types as enum-bases, see 7.2 [dcl.enum]/2.
 
    
+
 
    
-It might work like this:
+So, I think that we cannot leave the implementation the
+freedom to decide which way they would like to provide
+the implementation, because that is easily user-visible
+(I don't speak of addresses, but of instantiation errors),
+therefore if applied, this should be either specified or
+wording must be added that gives a note about this
+freedom of implementation.
 
    
-
    template<class E>
-exception_ptr make_exception_ptr(E e);
-template<>
-exception_ptr make_exception_ptr<exception_ptr>(exception_ptr e) = delete;
-
    
-
    
-
 
-
-
    Proposed resolution:
    
 
    
-Change 18.8.5 [propagation]:
+Another possible disadvantage seems to me that user-expectations
+are easy to disappoint if they see a failure
+of the test
 
    
 
-
    
-
    template<class E> exception_ptr copy_exceptionmake_exception_ptr(E e);
-
    
+
    assert(typeid(std::integral_constant<int, 0>::value) == typeid(int));
+
    
 
-
    
 
    
--11- Effects: Creates an exception_ptr that refers
-to a copy of e, as if
+or of
 
    
 
-
    try {
-  throw e;
-} catch(...) {
-  return current_exception();
-}
+
    static_assert(std::is_same<decltype(std::integral_constant<int, 0>::value), const int>::value, "Bad library");
 
    
 
-
    ...
    
 
    
 
-
    
 
 
+
    Proposed resolution:
    
+
 
 
 
 
 
    
-
    1131. C++0x does not need alignment_of
    
-
    Section: 20.6.4.3 [meta.unary.prop] Status: New
- Submitter: Niels Dekker Opened: 2009-06-01  Last modified: 2009-06-02
    
-
    View other active issues in [meta.unary.prop].
    
-
    View all other issues in [meta.unary.prop].
    
-
    View all issues with New status.
    
+
    1204. Global permission to move
    
+
    Section: 17.6.3.9 [res.on.arguments] Status: Ready
+ Submitter: Howard Hinnant Opened: 2009-09-12  Last modified: 2009-10-20
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
-The alignment_of template is no longer necessary, now that the
-core language will provide alignof. Scott Meyers raised this
-issue at comp.std.c++,
-C++0x: alignof vs. alignment_of,
-May 21, 2009.  In a reply, Daniel Krügler pointed out that
-alignof was added to the working paper after
-alignment_of. So it appears that alignment_of is only
-part of the current Working Draft 
-(N2857)
-because it is in TR1.
+When a library function binds an rvalue reference parameter to an argument, the
+library must be able to assume that the bound argument is a temporary, and not
+a moved-from lvalue.  The reason for this is that the library function must be
+able to modify that argument without concern that such modifications will corrupt
+the logic of the calling code.  For example:
+
    
+
+
    template <class T, class A>
+void
+vector<T, A>::push_back(value_type&& v)
+{
+    // This function should move from v, potentially modifying
+    //   the object v is bound to.
+}
+
    
+
+
    
+If v is truly bound to a temporary, then push_back has the
+only reference to this temporary in the entire program.  Thus any
+modifications will be invisible to the rest of the program.
 
    
+
 
    
-Having both alignof and alignment_of would cause
-unwanted confusion. In general, I think TR1 functionality should not be
-brought into C++0x if it is entirely redundant with other C++0x language
-or library features.
+If the client supplies std::move(x) to push_back, the onus is
+on the client to ensure that the value of x is no longer important to
+the logic of his program after this statement.  I.e. the client is making a statement
+that push_back may treat x as a temporary.
 
    
 
+
    
+The above statement is the very foundation upon which move semantics is based.
+
    
 
-
    Proposed resolution:
    
 
    
-Remove from Header <type_traits> synopsis 20.6.2 [meta.type.synop]:
+The standard is currently lacking a global statement to this effect.  I propose
+the following addition to 17.6.3.9 [res.on.arguments]:
 
    
-
    template <class T> struct alignment_of;
-
    
 
+
    
 
    
-Remove the first row of Table 34 ("Type property queries"), from
-Type properties 20.6.4.3 [meta.unary.prop]:
+Each of the following statements applies to all arguments to functions
+defined in the C++ standard library, unless explicitly stated otherwise.
 
    
+
      
+
    • 
+If an argument to a function has an invalid value (such as a value
+outside the domain of the function, or a pointer invalid for its
+intended use), the behavior is undefined.
+
      • 
+
    • 
+If a function argument is described as being an array, the pointer
+actually passed to the function shall have a value such that all address
+computations and accesses to objects (that would be valid if the pointer
+did point to the first element of such an array) are in fact valid.
+
      • 
+
    • 
+If a function argument binds to an rvalue reference parameter, the C++
+standard library may assume that this parameter is a unique reference
+to this argument.  If the parameter is a generic parameter of the
+form T&&, and an lvalue of type A is bound,
+then the binding is considered to be to an lvalue reference
+(14.9.2.1 [temp.deduct.call]) and thus not covered by this clause.
+[Note:
+If a program casts an lvalue to an rvalue while passing that lvalue to
+a library function (e.g. move(x)), then the program is effectively
+asking the library to treat that lvalue as a temporary.  The library is at
+liberty to optimize away aliasing checks which might be needed if the argument
+were an lvalue.
+— end note]
+
      • 
+
    
+
+
    
+
+
    
+Such a global statement will eliminate the need for piecemeal statements such as
+23.2.1 [container.requirements.general]/13:
+
    
+
 
    
-
-
-
-
-
-
-
    Table 34 -- Type property queries
    template <class T> struct alignment_of;alignof(T).
    
-Precondition: T shall be a complete type, a reference
-type, or an array of unknown bound, but shall not be a function type or
-(possibly cv-qualified) void.
-
    
+An object bound to an rvalue reference parameter of a member function of
+a container shall not be an element of that container; no diagnostic
+required.
 
    
 
 
    
-Change text in Table 41 ("Other transformations"), from Other
-transformations 20.6.7 [meta.trans.other], as follows:
+Additionally this clarifies that move assignment operators need not perform the
+traditional if (this != &rhs) test commonly found (and needed) in
+copy assignment operators.
 
    
+
+
    [
+2009-09-13 Niels adds:
+]
    
+
+
 
    
-
-
-
-
-
-
    Table 41 -- Other transformations
    ...
- Align shall be equal to 
- alignment_of<T>::value
- alignof(T)
-  for some type T or to default-alignment.
-...
    
+Note: This resolution supports the change of 27.9.1.3 [filebuf.assign]/1,
+proposed by LWG 900.
 
    
 
+
    [
+2009 Santa Cruz:
+]
    
 
 
+
    
+Move to Ready.
+
    
 
 
-
    
-
    1132. JP-30: nested exceptions
    
-
    Section: 18.8.6 [except.nested] Status: New
- Submitter: Seiji Hayashida Opened: 2009-06-01  Last modified: 2009-06-02
    
-
    View other active issues in [except.nested].
    
-
    View all other issues in [except.nested].
    
-
    View all issues with New status.
    
-
    Discussion:
    
-
    Addresses JP 30
    
 
+
    Proposed resolution:
    
 
    
-C++0x nested_exception cannot handle a structured exception well. The
-following codes show two types of tree structured exception handling.
-
    
-
    
-The first one is based on nested_exception in C++0x,
-while the second one is based on my library trickerr.h (in Japanese).
-http://tricklib.com/cxx/dagger/trickerr.h
-
    
-
    
-Assume that Function A() calls two sub functions A_a() and A_b(), both might
-throw tree structured exceptions, and A_b() must be called even if A_a()
-throws an exception.
+Add a bullet to 17.6.3.9 [res.on.arguments]:
 
    
+
+
    
 
    
-List A (code of tree structured exception handling based on nested_exception
-in C++0x)
+Each of the following statements applies to all arguments to functions
+defined in the C++ standard library, unless explicitly stated otherwise.
 
    
-
-
    void A()
-{
-    try
-    {
-        std::vector<exception_ptr> exception_list;
-        try
-        {
-            // A_a() does a similar processing as A().
-            A_a();
-        }
-        catch(...)
-        {
-            exception_list.push_back(current_exception());
-        }
-
-        // ***The processing A() has to do even when A_a() fails. ***
-        try
-        {
-            // A_b() does a similar processing as A().
-            A_b();
-        }
-        catch(...)
-        {
-            exception_list.push_back(current_exception());
-        }
-        if (!exception_list.empty())
-        {
-            throw exception_list;
-        }
-    }
-    catch(...)
-    {
-        throw_with_nested(A_exception("someone error"));
-    }
-}
-void print_tree_exception(exception_ptr e, const std::string & indent ="")
-{
-    const char * indent_unit = " ";
-    const char * mark = "- ";
-    try
-    {
-        rethow_exception(e);
-    }
-    catch(const std::vector<exception_ptr> e)
-    {
-        for(std::vector<exception_ptr>::const_iterator i = e.begin(); i!=e.end(); ++i)
-        {
-            print_tree_exception(i, indent);
-        }
-    }
-    catch(const std::nested_exception  e)
-    {
-        print_tree_exception(evil_i(e), indent +indent_unit);
-    }
-    catch(const std::exception e)
-    {
-        std::cout << indent << mark << e.what() << std::endl;
-    }
-    catch(...)
-    {
-        std::cout << indent << mark << "unknown exception" << std::endl;
-    }
-}
-int main(int, char * [])
-{
-    try
-    {
-        A();
-    }
-    catch()
-    {
-        print_tree_exception(current_exception());
-    }
-    return EXIT_SUCCESS;
-}
-
    
+
      
+
    • 
+If an argument to a function has an invalid value (such as a value
+outside the domain of the function, or a pointer invalid for its
+intended use), the behavior is undefined.
+
      • 
+
    • 
+If a function argument is described as being an array, the pointer
+actually passed to the function shall have a value such that all address
+computations and accesses to objects (that would be valid if the pointer
+did point to the first element of such an array) are in fact valid.
+
      • 
+
    • 
+If a function argument binds to an rvalue reference parameter, the C++
+standard library may assume that this parameter is a unique reference
+to this argument.  If the parameter is a generic parameter of the
+form T&&, and an lvalue of type A is bound,
+then the binding is considered to be to an lvalue reference
+(14.9.2.1 [temp.deduct.call]) and thus not covered by this clause.
+[Note:
+If a program casts an lvalue to an rvalue while passing that lvalue to
+a library function (e.g. move(x)), then the program is effectively
+asking the library to treat that lvalue as a temporary.  The library is at
+liberty to optimize away aliasing checks which might be needed if the argument
+were an lvalue.
+— end note]
+
      • 
+
    
+
    
 
 
    
-List B ( code of tree structured exception handling based on trickerr.h. )
-"trickerr.h" (in Japanese), refer to:
-http://tricklib.com/cxx/dagger/trickerr.h.
+Delete 23.2.1 [container.requirements.general]/13:
 
    
 
-
    void A()
-{
-    tricklib::error_listener_type error_listener;
-    // A_a() is like A(). A_a() can throw tree structured exception.
-    A_a();
+
    
+An object bound to an rvalue reference parameter of a member function of
+a container shall not be an element of that container; no diagnostic
+required.
+
    
 
-    // *** It must do process so that A_a() throws exception in A(). ***
-    // A_b() is like A(). A_b() can throw tree structured exception.
-    A_b();
 
-    if (error_listener.has_error()) // You can write this "if block" in destructor
-                                    //  of class derived from error_listener_type.
-    {
-        throw_error(new A_error("someone error",error_listener.listener_off().extract_pending_error()));
-    }
-}
-void print_tree_error(const tricklib::error_type &a_error, const std::string & indent = "")
-{
-    const char * indent_unit = " ";
-    const char * mark = "- ";
 
-    tricklib::error_type error = a_error;
-    while(error)
-    {
-        std::cout << indent << mark << error->message << std::endl;
-        if (error->children)
-        {
-            print_tree_error(error->children, indent +indent_unit);
-        }
-        error = error->next;
-    }
-}
-int main(int, char * [])
-{
-    tricklib::error_thread_power error_thread_power_on; // This object is necessary per thread.
 
-    try
-    {
-        A();
-    }
-    catch(error_type error)
-    {
-        print_tree_error(error);
-    }
-    catch(...)
-    {
-        std::cout << "- unknown exception" << std::endl;
-    }
-    return EXIT_SUCCESS;
-}
-
    
 
+
+
    
+
    1205. Some algorithms could more clearly document their handling of empty ranges
    
+
    Section: 25 [algorithms] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-09-13  Last modified: 2009-09-13
    
+
    View other active issues in [algorithms].
    
+
    View all other issues in [algorithms].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Prospect
+There are a number of algorithms whose result might depend on the
+handling of an empty range.  In some cases the result is not clear,
+while in others it would help readers to clearly mention the result
+rather than require some subtle intuition of the supplied wording.
 
    
+
 
    
-We will focus on the method A() since the other methods, also main(), occur
-only once respectively.
+25.2.1 [alg.all_of]
 
    
 
-
      
-
    • 
- In the List A above (of the nested exception handling), it is hard to
- find out an active reason to use the nested exception handling at this
- scene. Rather, we can take a simpler description by throwing the entire
- exception_list directly to the top level.
-
      • 
-
    • 
- The code in the same example gives us a kind of redundant impression,
- which might have come from the fact that the try-throw-catch framework does
- not assume a tree structured exception handling.
-
      • 
-
    
+
    
+Returns: true if pred(*i) is true for every
+iterator i in the range [first,last), ...
+
    
 
 
    
-According to the above observation, we cannot help concluding that it is not
-so easy to use the nested_exception handling as a tree structured exception
-handling mechanism in a practical sense.
+What does this mean if the range is empty?
 
    
+
 
    
-This text is based on the web page below (in Japanese).
-http://d.hatena.ne.jp/wraith13/20081231/1230715424
+I believe that we intend this to be true and suggest a
+non-normative note to clarify:
 
    
 
-
-
    Proposed resolution:
    
 
    
+Add to p1 25.2.1 [alg.all_of]:
 
    
 
+
    
+[Note: Returns true if [first,last) is empty. 
+— end note]
+
    
 
+
    
+25.2.3 [alg.none_of]
+
    
 
+
    
+Returns: true if pred(*i) is false for every
+iterator i in the range [first,last), ...
+
    
 
-
-
    
-
    1133. Does N2844 break current specification of list::splice?
    
-
    Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: New
- Submitter: Alisdair Meredith Opened: 2009-05-09  Last modified: 2009-06-09
    
-
    View other active issues in [forwardlist.ops].
    
-
    View all other issues in [forwardlist.ops].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-IIUC,
-N2844
-means that lvalues will no longer bind to rvalue references.
-Therefore, the current specification of list::splice (list
-operations 23.3.4.4 [list.ops]) will be a breaking change of behaviour for existing
-programs.  That is because we changed the signature to swallow via an rvalue
-reference rather than the lvalue reference used in 03.
+What does this mean if the range empty?
 
    
+
 
    
-Retaining this form would be safer, requiring an explicit move when splicing
-from lvalues.  However, this will break existing programs.
-We have the same problem with forward_list, although without the risk of
-breaking programs so here it might be viewed as a positive feature.
+I believe that we intend this to be true and suggest a
+non-normative note to clarify:
 
    
+
 
    
-The problem signatures:
+Add to p1 25.2.3 [alg.none_of]:
 
    
-
    void splice_after(const_iterator position, forward_list<T,Alloc>&& x);
-void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
-                  const_iterator i);
-void splice_after(const_iterator position, forward_list<T,Alloc>&& x,
-                  const_iterator first, const_iterator last);
-
-void splice(const_iterator position, list<T,Alloc>&& x);
-void splice(const_iterator position, list<T,Alloc>&& x,
-            const_iterator i);
-void splice(const_iterator position, list<T,Alloc>&& x,
-            const_iterator first, const_iterator last);
-
    
 
-Possible resolutions:
+
    
+[Note: Returns true if [first,last) is empty. 
+— end note]
+
    
 
 
    
-Option A.	Add an additional (non-const) lvalue-reference
-overload in each case
+25.2.2 [alg.any_of]
 
    
+
 
    
-Option B.	Change rvalue reference back to (non-const)
-lvalue-reference overload in each case
+The specification for an empty range is actually fairly clear in this
+case, but a note wouldn't hurt and would be consistent with proposals
+for all_of/none_of algorithms.
 
    
+
 
    
-Option C.	Add an additional (non-const) lvalue-reference
-overload in just the std::list cases
+Add to p1 25.2.2 [alg.any_of]:
 
    
+
+
    
+[Note: Returns false if [first,last) is empty. 
+— end note]
+
    
+
 
    
-I think (B) would be very unfortunate, I really like the forward_list
-behaviour in (C) but feel (A) is needed for consistency.
+25.2.6 [alg.find.end]
 
    
+
 
    
-My actual preference would be NAD, ship with this as a breaking change as it
-is a more explicit interface.  I don't think that will fly though!
+what does this mean if [first2,last2) is empty?
 
    
 
 
    
-See the thread starting with c++std-lib-23725 for more discussion.
+I believe the wording suggests the algorithm should return
+last1 in this case, but am not 100% sure. Is this in fact the
+correct result anyway? Surely an empty range should always match and the
+naive expected result would be first1?
 
    
 
+
    
+My proposed wording is a note to clarify the current semantic:
+
    
 
-
    Proposed resolution:
    
-
+
    
+Add to p2 25.2.6 [alg.find.end]:
+
    
 
+
    
+[Note: Returns last1 if [first2,last2) is
+empty. — end note]
+
    
 
+
    
+I would prefer a normative wording treating empty ranges specially, but
+do not believe we can change semantics at this point in the process,
+unless existing implementations actually yield this result:
+
    
 
+
    
+Alternative wording: (NOT a note)
+
    
+
    
+Add to p2 25.2.6 [alg.find.end]:
+
    
+
    
+Returns first1 if [first2,last2) is empty.
+
    
 
-
    
-
    1134. Redundant specification of stdint.h, fenv.h, tgmath.h, and maybe complex.h
    
-
    Section: 18.4.2 [stdinth], 26.3.2 [fenv], 26.8 [c.math], 26.4.11 [cmplxh] Status: New
- Submitter: Robert Klarer Opened: 2009-05-26  Last modified: 2009-06-14
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-This is probably editorial.
+25.2.7 [alg.find.first.of]
 
    
+
 
    
-The following items should be removed from the draft, because they're
-redundant with Annex D, and they arguably make some *.h headers
-non-deprecated:
+The phrasing seems precise when [first2, last2) is empty, but a small
+note to confirm the reader's understanding might still help.
 
    
+
 
    
-18.4.2 [stdinth] (regarding <stdint.h>) 
+Add to p2 25.2.7 [alg.find.first.of]
 
    
+
    
+[Note: Returns last1 if [first2,last2) is
+empty. — end note]
+
    
+
 
    
-26.3.2 [fenv] (regarding <fenv.h>
+25.2.12 [alg.search]
 
    
+
 
    
-Line 3 of 26.8 [c.math] (regarding <tgmath.h>) 
+What is the expected result if [first2, last2) is empty?
 
    
+
 
    
-26.4.11 [cmplxh] (regarding <complex.h>, though the note in this subclause is not redundant) 
+I believe the wording suggests the algorithm should return last1 in this
+case, but am not 100% sure. Is this in fact the correct result anyway? 
+Surely an empty range should always match and the naive expected result
+would be first1?
 
    
 
-
    [
-2009-06-10 Ganesh adds:
-]
    
+
    
+My proposed wording is a note to clarify the current semantic:
+
    
 
+
    
+Add to p2 25.2.12 [alg.search]:
+
    
 
 
    
-While searching for stdint in the CD, I found that <stdint.h> is also
-mentioned in 3.9.1 [basic.fundamental] /5. It guess it should refer to
-<cstdint> instead.
+[Note: Returns last1 if [first2,last2) is
+empty. — end note]
 
    
 
-
-
    Proposed resolution:
    
 
    
-Remove the section 18.4.2 [stdinth].
+Again, I would prefer a normative wording treating empty ranges
+specially, but do not believe we can change semantics at this point in
+the process, unless existing implementations actually yield this result:
 
    
+
 
    
-Remove the section 26.3.2 [fenv].
+Alternative wording: (NOT a note)
 
    
 
    
-Remove 26.8 [c.math], p3:
+Add to p2 25.2.12 [alg.search]:
 
    
 
 
    
--3- The header <tgmath.h> effectively includes the headers <complex.h>
-and <math.h>.
+Returns first1 if [first2,last2) is empty.
 
    
+
 
    
-Remove the section 26.4.11 [cmplxh].
+25.3.13 [alg.partitions]
 
    
 
-
-
-
-
-
    
-
    1135. exception_ptr should support contextual conversion to bool
    
-
    Section: 18.8.5 [propagation] Status: New
- Submitter: Daniel Krügler Opened: 2007-06-06  Last modified: 2009-06-09
    
-
    View other active issues in [propagation].
    
-
    View all other issues in [propagation].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-As of
-N2857
-18.8.5 [propagation]/5, the implementation-defined type
-exception_ptr does provide the following ways to check whether
-it is a null value:
+Is an empty range partitioned or not?
 
    
-
    void f(std::exception_ptr p) {
-  p == nullptr;
-  p == 0;
-  p == exception_ptr();
-}
-
    
+
 
    
-This is rather cumbersome way of checking for the null value
-and I suggest to require support for evaluation in a boolean
-context like so:
+Proposed wording:
 
    
 
-
    void g(std::exception_ptr p) {
-  if (p) {}
-  !p;
-}
-
    
+
    
+Add to p1 25.3.13 [alg.partitions]:
+
    
 
+
    
+[Note: Returns true if [first,last) is empty. 
+— end note]
+
    
 
-
    Proposed resolution:
    
 
    
-In section 18.8.5 [propagation] insert a new paragraph between p.5 and p.6:
+25.4.5.1 [includes]
 
    
 
 
    
-
-An object e of type exception_ptr can be contextually converted to bool.
-The effect shall be as if e != exception_ptr() had been evaluated in place
-of e. There shall be no implicit conversion to arithmetic type, to
-enumeration type or to pointer type.
-
+Returns: true if every element in the range
+[first2,last2) is contained in the range
+[first1,last1). ...
 
    
 
+
    
+I really don't know what this means if [first2,last2) is empty.
+I could loosely guess that this implies empty ranges always match, and
+my proposed wording is to clarify exactly that:
+
    
 
+
    
+Add to p1 25.4.5.1 [includes]:
+
    
 
+
    
+[Note: Returns true if [first2,last2) is empty.
+— end note]
+
    
 
+
    
+25.4.6.2 [pop.heap]
+
    
 
-
    
-
    1136. Incomplete specification of nested_exception::rethrow_nested()
    
-
    Section: 18.8.6 [except.nested] Status: New
- Submitter: Daniel Krügler Opened: 2007-06-06  Last modified: 2009-06-09
    
-
    View other active issues in [except.nested].
    
-
    View all other issues in [except.nested].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-It was recently mentioned in a newsgroup article
-http://groups.google.de/group/comp.std.c++/msg/f82022aff68edf3d
-that the specification of the member function rethrow_nested() of the
-class nested_exception is incomplete, specifically it remains unclear
-what happens, if member nested_ptr() returns a null value. In
-18.8.6 [except.nested] we find only the following paragraph related to that:
+The effects clause is invalid if the range [first,last) is empty, unlike
+all the other heap alogorithms.  The should be called out in the
+requirements.
 
    
-
    void rethrow_nested() const; // [[noreturn]]
-
    
+
+
    
+Proposed wording:
+
    
+
    
+Revise p2 25.4.6.2 [pop.heap]
+
    
+
 
    
--4- Throws: the stored exception captured by this nested_exception object.
-
    
+Requires: The range [first,last) shall be a valid
+non-empty heap.
 
    
+
 
    
-This is a problem, because it is possible to create an object of
-nested_exception with exactly such a state, e.g.
+[Editorial] Reverse order of 25.4.6.2 [pop.heap] p1 and p2.
 
    
-
    #include <exception>
-#include <iostream>
 
-int main() try {
-  std::nested_exception e; // OK, calls current_exception() and stores it's null value
-  e.rethrow_nested(); // ?
-  std::cout << "A" << std::endl;
-}
-catch(...) {
-  std::cout << "B" << std::endl;
-}
-
    
 
    
-I suggest to follow the proposal of the reporter, namely to invoke
-terminate() if nested_ptr() return a null value of exception_ptr instead
-of relying on the fallback position of undefined behavior. This would
-be consistent to the behavior of a throw; statement when no
-exception is being handled.
+25.4.7 [alg.min.max]
 
    
 
+
    
+minmax_element does not clearly specify behaviour for an empty
+range in the same way that min_element and max_element do.
+
    
 
-
    Proposed resolution:
    
 
    
-Change around 18.8.6 [except.nested]/4 as indicated:
+Add to p31 25.4.7 [alg.min.max]:
 
    
+
 
    
+Returns make_pair(first, first) if first == last.
+
    
+
 
    
--4- Throws: the stored exception captured by this nested_exception
-object, if nested_ptr() != nullptr
+25.4.8 [alg.lex.comparison]
 
    
+
 
    
-- Remarks: If nested_ptr() == nullptr, terminate()
-shall be called.
+The wording here seems quite clear, especially with the sample algorithm
+implementation.  A note is recommended purely for consistency with the
+rest of these issue resolutions:
 
    
-
    
-
 
+
    
+Add to p1 25.4.8 [alg.lex.comparison]:
+
    
 
+
    
+[Note: An empty sequence is lexicographically less than any other
+non-empty sequence, but not to another empty sequence. — end note]
+
    
 
 
-
    
-
    1137. Return type of conj and proj
    
-
    Section: 26.4.9 [cmplx.over] Status: New
- Submitter: Marc Steinbach Opened: 2009-06-11  Last modified: 2009-06-27
    
-
    View all other issues in [cmplx.over].
    
-
    View all issues with New status.
    
-
    Discussion:
    
+
    Proposed resolution:
    
 
    
-In clause 1, the Working Draft 
-(N2857)
-specifies overloads of the
-functions
+Add to p1 25.2.1 [alg.all_of]:
 
    
-
    arg, conj, imag, norm, proj, real
-
    
+
    
+[Note: Returns true if [first,last) is empty. 
+— end note]
+
    
+
 
    
-for non-complex arithmetic types (float, double,
-long double, and integers).
-The only requirement (clause 2) specifies effective type promotion of arguments.
+Add to p1 25.2.2 [alg.any_of]:
 
    
+
    
+[Note: Returns false if [first,last) is empty. 
+— end note]
+
    
+
 
    
-I strongly suggest to add the following requirement on the return types:
+Add to p1 25.2.3 [alg.none_of]:
 
    
 
    
-All the specified overloads must return real (i.e., non-complex) values,
-specifically, the nested value_type of effectively promoted arguments.
+[Note: Returns true if [first,last) is empty. 
+— end note]
 
    
 
 
    
-(This has no effect on arg, imag, norm, real:
-they are real-valued anyway.)
+Add to p2 25.2.6 [alg.find.end]:
 
    
-
    Rationale:
    
+
    
+[Note: Returns last1 if [first2,last2) is
+empty.  — end note]
+
    
+
 
    
-Mathematically, conj() and proj(), like the transcendental functions, are
-complex-valued in general but map the (extended) real line to itself.
-In fact, both functions act as identity on the reals.
-A typical user will expect conj() and proj() to preserve this essential
-mathematical property in the same way as exp(), sin(), etc.
-A typical use of conj(), e.g., is the generic scalar product of n-vectors:
+Add to p2 25.2.7 [alg.find.first.of]
 
    
+
    
+[Note: Returns last1 if [first2,last2) is
+empty.  — end note]
+
    
 
-
    template<typename T>
-inline T
-scalar_product(size_t n, T const* x, T const* y) {
-  T result = 0;
-  for (size_t i = 0; i < n; ++i)
-    result += x[i] * std::conj(y[i]);
-  return result;
-}
-
    
 
    
-This will work equally well for real and complex floating-point types T if
-conj() returns T. It will not work with real types if conj()
-returns complex values.
+Add to p2 25.2.12 [alg.search]:
 
    
+
    
+[Note: Returns last1 if [first2,last2) is
+empty.  — end note]
+
    
+
 
    
-Instead, the implementation of scalar_product becomes either less efficient
-and less useful (if a complex result is always returned), or unnecessarily
-complicated (if overloaded versions with proper return types are defined).
-In the second case, the real-argument overload of conj() cannot be used.
-In fact, it must be avoided.
+Add to p1 25.3.13 [alg.partitions]:
 
    
-
    
-Overloaded conj() and proj() are principally needed in generic programming.
-All such use cases will benefit from the proposed return type requirement,
-in a similar way as the scalar_product example.
-The requirement will not harm use cases where a complex return value
-is expected, because of implicit conversion to complex.
-Without the proposed return type guarantee, I find overloaded versions
-of conj() and proj() not only useless but actually troublesome.
+
    
+[Note: Returns true if [first,last) is empty. 
+— end note]
+
    
+
+
    
+Add to p1 25.4.5.1 [includes]:
 
    
+
    
+[Note: Returns true if [first2,last2) is empty. 
+— end note]
+
    
 
+
    
+Revise p2 25.4.6.2 [pop.heap]
+
    
+
    
+Requires: The range [first,last) shall be a valid
+non-empty heap.
+
    
 
+
    
+[Editorial] 
+
    
+
    
+Reverse order of 25.4.6.2 [pop.heap] p1 and p2.
+
    
 
-
    Proposed resolution:
    
 
    
-Insert a new paragraph after 26.4.9 [cmplx.over]/2:
+Add to p31 25.4.7 [alg.min.max]:
 
    
+
    
+Returns make_pair(first, first) if first == last.
+
    
 
+
    
+Add to p1 25.4.8 [alg.lex.comparison]:
+
    
 
    
-
-All of the specified overloads shall have a return type which is the nested value_type of
-the effectively promoted arguments.
-
+[Note: An empty sequence is lexicographically less than any other
+non-empty sequence, but not less than another empty sequence. —
+end note]
 
    
 
 
 
 
 
+
 
    
-
    1138. unusal return value for operator+
    
-
    Section: 21.4.8.1 [string::op+] Status: New
- Submitter: Alisdair Meredith Opened: 2009-06-12  Last modified: 2009-06-15
    
+
    1206. Incorrect requires for move_backward and copy_backward
    
+
    Section: 25.3.2 [alg.move] Status: New
+ Submitter: Howard Hinnant Opened: 2009-09-13  Last modified: 2009-09-13
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-Many of the basic_string operator+ overloads return an rvalue-reference.  Is
-that really intended?
+25.3.2 [alg.move], p6 says:
 
    
+
+
    
+
    template<class BidirectionalIterator1, class BidirectionalIterator2>
+  BidirectionalIterator2
+    move_backward(BidirectionalIterator1 first,
+                  BidirectionalIterator1 last,
+                  BidirectionalIterator2 result);
+
    
+
    
+
    ...
    
 
    
-I'm considering it might be a mild performance tweak to avoid making
-un-necessary copies of a cheaply movable type, but it opens risk to dangling
-references in code like:
+Requires: result shall not be in the range
+[first,last).
 
    
-
-
    auto && s = string{"x"} + string{y};
-
    
+
    
+
    
 
 
    
-and I'm not sure about:
+This is essentially an "off-by-one" error.
 
    
 
-
    auto s = string{"x"} + string{y};
-
    
-
-
-
    Proposed resolution:
    
 
    
-Strike the && from the return type in the following function
-signatures:
+When result == last, which
+is allowed by this specification, then the range [first, last)
+is being move assigned into the range [first, last).  The move
+(forward) algorithm doesn't allow self move assignment, and neither should
+move_backward.  So last should be included in the range which
+result can not be in.
 
    
 
-
    
 
    
-21.3 [string.classes] p2 Header Synopsis
+Conversely, when result == first, which is not allowed by this
+specification, then the range [first, last)
+is being move assigned into the range [first - (last-first), first).
+I.e. into a non-overlapping range.  Therefore first should
+not be included in the range which result can not be in.
 
    
 
-
    template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              const basic_string<charT,traits,Allocator>& rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(const basic_string<charT,traits,Allocator>& lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(const charT* lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              const charT* rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);
-
    
-
 
    
-21.4.8.1 [string::op+]
+The same argument applies to copy_backward though copy assigning elements
+to themselves (result == last) should be harmless (though is disallowed
+by copy).
 
    
 
-
    template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              const basic_string<charT,traits,Allocator>& rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(const basic_string<charT,traits,Allocator>& lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
-
 
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(const charT* lhs,
-              basic_string<charT,traits,Allocator>&& rhs);
 
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(charT lhs, basic_string<charT,traits,Allocator>&& rhs);
+
    Proposed resolution:
    
+
    
+Change 25.3.2 [alg.move], p6:
+
    
 
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs,
-              const charT* rhs);
+
    
+
    template<class BidirectionalIterator1, class BidirectionalIterator2>
+  BidirectionalIterator2
+    move_backward(BidirectionalIterator1 first,
+                  BidirectionalIterator1 last,
+                  BidirectionalIterator2 result);
+
    
+
    
+
    ...
    
+
    
+Requires: result shall not be in the range
+[(first,last]).
+
    
+
    
+
    
 
-template<class charT, class traits, class Allocator>
-  basic_string<charT,traits,Allocator>&&
-    operator+(basic_string<charT,traits,Allocator>&& lhs, charT rhs);
-
    
+
    
+Change 25.3.1 [alg.copy], p13:
+
    
 
+
    
+
    template<class BidirectionalIterator1, class BidirectionalIterator2>
+  BidirectionalIterator2
+    copy_backward(BidirectionalIterator1 first,
+                  BidirectionalIterator1 last,
+                  BidirectionalIterator2 result);
+
    
+
    
+
    ...
    
+
    
+Requires: result shall not be in the range
+[(first,last]).
+
    
+
    
 
    
-
 
 
 
 
 
 
    
-
    1144. "thread safe" is undefined
    
-
    Section: 18.5 [support.start.term] Status: New
- Submitter: LWG Opened: 2009-06-16  Last modified: 2009-07-04
    
-
    View all other issues in [support.start.term].
    
+
    1207. Underspecified std::list operations?
    
+
    Section: 23.3.4.4 [list.ops] Status: New
+ Submitter: Loďc Joly Opened: 2009-09-13  Last modified: 2009-09-19
    
+
    View other active issues in [list.ops].
    
+
    View all other issues in [list.ops].
    
 
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses UK 187
    
-
 
    
-The term "thread safe" is not defined nor used in this context
-anywhere else in the standard.
+It looks to me like some operations of std::list
+(sort, reverse, remove, unique &
+merge) do not specify the validity of iterators, pointers &
+references to elements of the list after those operations. Is it implied
+by some other text in the standard?
 
    
 
-
    Suggested action:
    
 
    
-Clarify the meaning of "thread safe".
+I believe sort & reverse do not invalidating
+anything, remove & unique only invalidates what
+refers to erased elements, merge does not invalidate anything
+(with the same precision as splice for elements who changed of
+container). Are those assumptions correct ?
 
    
 
 
@@ -29450,379 +25203,397 @@ Clarify the meaning of "thread safe".
 
 
 
    
-
    1145. inappropriate headers for atomics
    
-
    Section: 29 [atomics] Status: New
- Submitter: LWG Opened: 2009-06-16  Last modified: 2009-07-04
    
-
    View other active issues in [atomics].
    
-
    View all other issues in [atomics].
    
-
    View all issues with New status.
    
+
    1208. valarray initializer_list constructor has incorrect effects
    
+
    Section: 26.6.2.1 [valarray.cons] Status: Tentatively Ready
+ Submitter: Howard Hinnant Opened: 2009-09-23  Last modified: 2009-10-29
    
+
    View all other issues in [valarray.cons].
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
+
    
+26.6.2.1 [valarray.cons] says:
+
    
 
-
    Addresses UK 312
    
+
    
+
    valarray(initializer_list<T> il);
+
    
+
    
+Effects: Same as valarray(il.begin(), il.end()).
+
    
+
    
 
 
    
-The contents of the <stdatomic.h> header are not listed anywhere,
-and <cstdatomic> is listed as a C99 header in chapter 17.
-If we intend to use these for compatibility with a future C standard,
-we should not use them now.
+But there is no valarray constructor taking two const T*.
 
    
 
+
    [
+2009-10-29 Howard:
+]
    
+
+
+
    
+Moved to Tentatively Ready after 6 positive votes on c++std-lib.
+
    
+
 
 
    Proposed resolution:
    
 
    
-Remove <cstdatomic> from the C99 headers in table 14.
-Add a new header <atomic> to the headers in table 13.
-Update chapter 29 to remove reference to <stdatomic.h>
-and replace the use of <cstdatomic> with <atomic>.
+Change 26.6.2.1 [valarray.cons]:
 
    
-
    [
-If and when WG14 adds atomic operations to C
-we can add corresponding headers to table 14 with a TR.
-]
    
 
+
    
+
    valarray(initializer_list<T> il);
+
    
+
    
+Effects: Same as valarray(il.begin(), il.endsize()).
+
    
+
    
 
 
 
 
 
 
    
-
    1146. "lockfree" does not say enough
    
-
    Section: 29.4 [atomics.lockfree] Status: New
- Submitter: Jeffrey Yasskin Opened: 2009-06-16  Last modified: 2009-07-04
    
+
    1209. match_results should be moveable
    
+
    Section: 28.10.1 [re.results.const] Status: New
+ Submitter: Stephan T. Lavavej Opened: 2009-09-15  Last modified: 2009-09-21
    
 
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses US 88
    
+
    
+In Working Draft
+N2914,
+match_results lacks a move constructor and move
+assignment operator. Because it owns dynamically allocated memory, it
+should be moveable.
+
    
 
 
    
-The "lockfree" facilities do not tell the programmer enough.
+As far as I can tell, this isn't tracked by an active issue yet; Library
+Issue 723 doesn't talk about match_results.
 
    
 
+
    [
+2009-09-21 Daniel provided wording.
+]
    
+
+
+
+
    Proposed resolution:
    
+
      
+
    1. 
 
      
-There are 2 problems here.
-First, at least on x86,
-it's less important to me whether some integral types are lock free
-than what is the largest type I can pass to atomic and have it be lock-free.
-For example, if long longs are not lock-free,
-ATOMIC_INTEGRAL_LOCK_FREE is probably 1,
-but I'd still be interested in knowing whether longs are always lock-free.
-Or if long longs at any address are lock-free,
-I'd expect ATOMIC_INTEGRAL_LOCK_FREE to be 2,
-but I may actually care whether I have access to
-the cmpxchg16b instruction.
-None of the support here helps with that question.
-(There are really 2 related questions here:
-what alignment requirements are there for lock-free access;
-and what processor is the program actually running on,
-as opposed to what it was compiled for?)
+Add the following member declarations to 28.10 [re.results]/3:
 
      
 
+
      // 28.10.1, construct/copy/destroy:
+explicit match_results(const Allocator& a = Allocator());
+match_results(const match_results& m);
+match_results(match_results&& m);
+match_results& operator=(const match_results& m);
+match_results& operator=(match_results&& m);
+~match_results();
+
      
+
      2. 
+
+
    2. 
 
      
-Second, having atomic_is_lock_free only apply to individual objects
-is pretty useless
-(except, as Lawrence Crowl points out,
-for throwing an exception when an object is unexpectedly not lock-free).
-I'm likely to want to use its result to decide what algorithm to use,
-and that algorithm is probably going to allocate new memory
-containing atomic objects and then try to act on them.
-If I can't predict the lock-freedom of the new object
-by checking the lock-freedom of an existing object,
-I may discover after starting the algorithm that I can't continue.
+Add the following new prototype descriptions to 28.10.1 [re.results.const]
+using the table numbering of
+N2723:
 
      
 
-
      [
-2009-06-16 Jeffrey Yasskin adds:
-]
      
+
      
+
      match_results(const match_results& m);
+
      
 
+
      
+4 Effects: Constructs an object of class match_results, as a
+copy of m.
+
      
+
+
      match_results(match_results&& m);
+
      
 
 
      
 
      
-To solve the first problem, I think 2 macros would help:
-MAX_POSSIBLE_LOCK_FREE_SIZE and MAX_GUARANTEED_LOCK_FREE_SIZE,
-which expand to the maximum value of sizeof(T) for which atomic may
-(or will, respectively) use lock-free operations.
-Lawrence points out that this
-"relies heavily on implementations
-using word-size compare-swap on sub-word-size types,
-which in turn requires address modulation."
-He expects that to be the end state anyway, so it doesn't bother him much.
+5 Effects: Move-constructs an object of class match_results
+from m satisfying the same postconditions as Table 132. Additionally
+the stored Allocator value is move constructed from m.get_allocator().
+After the initialization of *this sets m to an unspecified but valid
+state.
 
      
 
 
      
-To solve the second,
-I think one could specify that equally aligned objects of the same type
-will return the same value from atomic_is_lock_free().
-I don't know how to specify "equal alignment".
-Lawrence suggests an additional function, atomic_is_always_lock_free().
+6 Throws: Nothing if the allocator's move constructor throws nothing.
 
      
 
      
 
+
      match_results& operator=(const match_results& m);
+
      
 
+
      
+7 Effects: Assigns m to *this. The postconditions of this function are
+indicated in Table 132.
+
      
 
-
      Proposed resolution:
      
+
      match_results& operator=(match_results&& m);
+
      
+
+
      
+
      
+8 Effects: Move-assigns m to *this. The postconditions of this
+function are indicated in Table 132. After the assignment, m is in
+a valid but unspecified state.
+
      
+
+
      
+9 Throws: Nothing.
+
      
+
      
+
      
+
      3. 
+
+
    
 
 
 
 
 
 
    
-
    1147. non-volatile atomic functions
    
-
    Section: 29.6 [atomics.types.operations] Status: New
- Submitter: Jeffrey Yasskin Opened: 2009-06-16  Last modified: 2009-07-04
    
-
    View other active issues in [atomics.types.operations].
    
-
    View all other issues in [atomics.types.operations].
    
+
    1210. iterator reachability should not require a container
    
+
    Section: 24.2 [iterator.requirements] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-09-18  Last modified: 2009-09-19
    
+
    View other active issues in [iterator.requirements].
    
+
    View all other issues in [iterator.requirements].
    
 
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses US 90
    
-
 
    
-The C++0X draft
-declares all of the functions dealing with atomics (section 29.6 [atomics.types.operations])
-to take volatile arguments.
-Yet it also says (29.4-3),
+p6 Iterator requirements 24.2 [iterator.requirements]
 
    
 
 
    
-
    
-[ Note: Many operations are volatile-qualified.
-The "volatile as device register" semantics have not changed in the standard.
-This qualification means that volatility is preserved
-when applying these operations to volatile objects.
-It does not mean that operations on non-volatile objects become volatile.
-Thus, volatile qualified operations on non-volatile objects
-may be merged under some conditions. —end note ]
-
    
+An iterator j is called reachable from an iterator i if and only if
+there is a finite sequence of applications of the expression ++i that
+makes i == j. If j is reachable from i, they refer to the same
+container.
 
    
 
 
    
-I was thinking about how to implement this in gcc,
-and I believe that we'll want to overload most of the functions
-on volatile and non-volatile.
-Here's why:
+A good example would be stream iterators, which do not refer to a
+container.  Typically, the end iterator from a range of stream iterators
+will compare equal for many such ranges.  I suggest striking the second
+sentence.
 
    
 
 
    
-To let the compiler take advantage of the permission
-to merge non-volatile atomic operations and reorder atomics in certain,
-we'll need to tell the compiler backend
-about exactly which atomic operation was used.
-So I expect most of the functions of the form atomic_<op>_explicit()
-(e.g. atomic_load_explicit, atomic_exchange_explicit,
-atomic_fetch_add_explicit, etc.)
-to become compiler builtins.
-A builtin can tell whether its argument was volatile or not,
-so those functions don't really need extra explicit overloads.
-However, I don't expect that we'll want to add builtins
-for every function in chapter 29,
-since most can be implemented in terms of the _explicit free functions:
+An alternative wording might be:
 
    
 
-
    class atomic_int {
-  __atomic_int_storage value;
- public:
-  int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
-    // &value has type "volatile __atomic_int_storage*".
-    atomic_fetch_add_explicit(&value, increment, order);
-  }
-  ...
-};
-
    
+
    
+If j is reachable from i, and both i and
+j are dereferencable iterators, then they refer to the same
+range.
+
    
 
+
+
    Proposed resolution:
    
 
    
-But now this always calls
-the volatile builtin version of atomic_fetch_add_explicit(),
-even if the atomic_int wasn't declared volatile.
-To preserve volatility and the compiler's permission to optimize,
-I'd need to write:
+Change 24.2 [iterator.requirements], p6:
 
    
 
-
    class atomic_int {
-  __atomic_int_storage value;
- public:
-  int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
-    atomic_fetch_add_explicit(&value, increment, order);
-  }
-  int fetch_add(int increment, memory_order order = memory_order_seq_cst) {
-    atomic_fetch_add_explicit(&value, increment, order);
-  }
-  ...
-};
-
    
+
    
+An iterator j is called reachable from an iterator
+i if and only if there is a finite sequence of applications of
+the expression ++i that makes i == j. If
+j is reachable from i, they refer to the same
+container.
+
    
+
+
 
-
    
-But this is visibly different from the declarations in the standard
-because it's now overloaded.
-(Consider passing &atomic_int::fetch_add as a template parameter.)
-
    
 
+
+
    
+
    1211. move iterators should be restricted as input iterators
    
+
    Section: 24.5.3.1 [move.iterator] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-09-18  Last modified: 2009-10-26
    
+
    View all other issues in [move.iterator].
    
+
    View all issues with Open status.
    
+
    Discussion:
    
 
    
-The implementation may already have permission to add overloads
-to the member functions:
+I contend that while we can support both bidirectional and random access
+traversal, the category of a move iterator should never be better than
+input_iterator_tag.
 
    
 
-
    
 
    
-17.6.4.5 [member.functions] An implementation may declare additional non-virtual
-member function signatures within a class:
    
-...
+The contentious point is that you cannot truly have a multipass property
+when values are moved from a range.  This is contentious if you view a
+moved-from object as still holding a valid value within the range.  
 
    
-
      
-
    • by adding a member function signature for a member function name.
      • 
-
    
-
    
 
 
    
-but I don't see an equivalent permission to add overloads to the free functions.
+The second reason comes from the Forward Iterator requirements table:
 
    
 
-
    [
-2009-06-16 Lawrence adds:
-]
    
-
-
 
    
 
    
-I recommend allowing non-volatile overloads.
+Forward iterators 24.2.3 [forward.iterators]
 
    
-
    
-
-
-
-
    Proposed resolution:
    
-
-
 
+
    
+Table 102 -- Forward iterator requirements
+
    
 
+
    
+For expression *a the return type is:
+"T& if X is mutable, otherwise const T&"
+
    
+
    
 
-
    
-
    1148. Wrong argument type of I/O stream manipulators setprecision()
-and setw()
    
-
    Section: 27.7 [iostream.format] Status: New
- Submitter: Marc Steinbach Opened: 2009-06-20  Last modified: 2009-07-30
    
-
    View all other issues in [iostream.format].
    
-
    View all issues with New status.
    
-
    Discussion:
    
 
    
-The header <iomanip> synopsis in 27.7 [iostream.format] specifies
+There is a similar constraint on a->m.
 
    
-
    T5 setprecision(int n);
-T6 setw(int n);
-
    
 
 
    
-The argument types should be streamsize, as in class ios_base
-(see 27.5.2 [ios.base]):
+There is no support for rvalue references, nor do I believe their should
+be.  Again, opinions may vary but either this table or the definition of
+move_iterator need updating.
 
    
-
    streamsize precision() const;
-streamsize precision(streamsize prec);
-streamsize width() const;
-streamsize width(streamsize wide);
-
    
 
 
    
-(Editorial: 'wide' should probably be renamed as 'width', or maybe just 'w'.)
+Note: this requirement probably need updating anyway if we wish to
+support proxy iterators but I am waiting to see a new working paper
+before filing that issue.
 
    
 
 
    [
-2009-07-29 Daniel clarified wording.
+2009-10 post-Santa Cruz:
 ]
    
 
 
+
    
+Move to Open. Howard to put his rationale mentioned above into the issue
+as a note.
+
    
+
+
    [
+2009-10-26 Howard adds:
+]
    
+
 
-
    Proposed resolution:
    
-
      
-
    1. 
+
      
 
      
-In 27.7 [iostream.format], header <iomanip> synopsis change as indicated:
+vector::insert(pos, iter, iter) is significantly more effcient when
+iter is a random access iterator, as compared to when it is an
+input iterator.
 
      
 
-
      T5 setprecision(intstreamsize n);
-T6 setw(intstreamsize n);
-
      
-
      2. 
+
      
+When iter is an input iterator, the best algorithm
+is to append the inserted range to the end of the vector using
+push_back.  This may involve several reallocations before the input
+range is exhausted.  After the append, then one can use std::rotate
+to place the inserted range into the correct position in the vector.
+
      
 
-
    2. 
 
      
-In 27.7.3 [std.manip], just before p. 6 change as indicated:
+But when iter is a random access iterator, the best algorithm
+is to first compute the size of the range to be inserted (last - first),
+do a buffer reallocation if necessary, scoot existing elements in the vector
+down to make the "hole", and then insert the new elements directly to their correct
+place.
 
      
 
-
      unspecified setprecision(intstreamsize n);
-
      
-
      3. 
+
      
+The insert-with-random-access-iterators algorithm is considerably more efficient
+than the insert-with-input-iterators algorithm
+
      
 
-
    3. 
 
      
-In 27.7.3 [std.manip], just before p. 7 change as indicated:
+Now consider:
 
      
 
-
      unspecified setw(intstreamsize n);
+
      vector<A> v;
+//  ... build up a large vector of A ...
+vector<A> temp;
+//  ... build up a large temporary vector of A to later be inserted ...
+typedef move_iterator<vector<A>::iterator> MI;
+//  Now insert the temporary elements:
+v.insert(v.begin() + N, MI(temp.begin()), MI(temp.end()));
 
      
-
      4. 
-
    
-
-
-
-
-
-
 
+
    
+A major motivation for using move_iterator in the above example is the
+expectation that A is cheap to move but expensive to copy.  I.e. the
+customer is looking for high performance.  If we allow vector::insert
+to subtract two MI's to get the distance between them, the customer enjoys
+substantially better performance, compared to if we say that vector::insert
+can not subtract two MI's.
+
    
 
-
    
-
    1150. wchar_t, char16_t and char32_t filenames
    
-
    Section: 27.9.1.14 [fstream] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-04
    
-
    View all issues with New status.
    
-
    Discussion:
    
-
    Addresses JP 73
    
+
    
+I can find no rationale for not giving this performance boost to our customers.
+Therefore I am strongly against restricting move_iterator to the
+input_iterator_tag category.
+
    
 
-   
    Description
    
-        
    It is a problem
-        from C++98, fstream cannot appoint a filename of wide
-        character string(const wchar_t and const wstring&).
    
-
    Suggestion
    
-        
    Add
-        interface corresponding to wchar_t, char16_t and char32_t.
    
+
    
+I believe that the requirement that forward
+iterators have a dereference that returns an lvalue reference to cause unacceptable
+pessimization.  For example vector<bool>::iterator also does not return
+a bool& on dereference.  Yet I am not aware of a single vendor that
+is willing to ship vector<bool>::iterator as an input iterator.
+Everyone classifies it as a random access iterator.  Not only does this not
+cause any problems, it prevents significant performance problems.
+
    
 
-
    [
-2009-07-01 Alisdair notes that this is a duplicate of 454 which has more
-in-depth rationale.
-]
    
+
    
 
 
 
 
    Proposed resolution:
    
+
    
+Class template move_iterator 24.5.3.1 [move.iterator]
+
    
+
+
    namespace std {
+template <class Iterator>
+class move_iterator {
+public:
+ ...
+ typedef typename iterator_traits<Iterator>::iterator_category input_iterator_tag iterator_category;
+
    
 
 
 
 
 
 
    
-
    1151. Behavior of the library in the presence of threads is incompletely specified
    
-
    Section: 17 [library] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-06-28
    
-
    View other active issues in [library].
    
-
    View all other issues in [library].
    
+
    1212. result of post-increment/decrement operator
    
+
    Section: 24.2 [iterator.requirements] Status: New
+ Submitter: Alisdair Meredith Opened: 2009-09-18  Last modified: 2009-09-19
    
+
    View other active issues in [iterator.requirements].
    
+
    View all other issues in [iterator.requirements].
    
 
    View all issues with New status.
    
 
    Discussion:
    
-
    Addresses US 63
    
+
    Forward iterator and bidirectional iterator place different
+requirements on the result of post-increment/decrement operator. The
+same form should be used in each case.
+
    
 
-   
    Description
    
-        
    The behavior of the library in the presence of threads
-        is incompletely specified.
    
-        
    For example, if thread 1 assigns to X, then writes data
-        to file f, which is read by thread 2, and then accesses
-        variable X, is thread 2 guaranteed to be able to see the
-        value assigned to X by thread 1? In other words, does the
-        write of the data "happen before" the read?
    
-        
    Another example: does simultaneous access using operator
-        at() to different characters in the same non-const string
-        really introduce a data race?
    
-
    Suggestion
    
-
    Notes
    17 SG: should go to threads group; misclassified in document
+
    
+Merging row from:
 
    
 
-    
    Concurrency SG: Create an issue. Hans will look into it.
    
+
    Table 102 -- Forward iterator requirements
+Table 103 -- Bidirectional iterator requirements
+
+    r++ : convertible to const X&
+    r-- : convertible to const X&
+    
+    *r++ : T& if X is mutable, otherwise const T&
+    *r-- : convertible to T
+
    
 
 
 
    Proposed resolution:
    
@@ -29832,167 +25603,129 @@ in-depth rationale.
 
 
 
    
-
    1152. expressions parsed differently than intended
    
-
    Section: 22.4.2.2.2 [facet.num.put.virtuals] Status: New
- Submitter: Seungbeom Kim Opened: 2009-06-27  Last modified: 2009-07-24
    
-
    View other active issues in [facet.num.put.virtuals].
    
-
    View all other issues in [facet.num.put.virtuals].
    
+
    1213. Meaning of valid and singular iterator underspecified
    
+
    Section: 24.2 [iterator.requirements] Status: New
+ Submitter: Daniel Krügler Opened: 2009-09-19  Last modified: 2009-09-19
    
+
    View other active issues in [iterator.requirements].
    
+
    View all other issues in [iterator.requirements].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-In Table 73 -- Floating-point conversions, 22.4.2.2.2 [facet.num.put.virtuals], 
-in
-N2914,
-we have the following entries: 
+The terms valid iterator and singular aren't
+properly defined. The fuzziness of those terms became even worse
+after the resolution of 208 (including further updates by 278). In
+24.2 [iterator.requirements] as of
+N2723
+the standard says now:
 
    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    Table 73 — Floating-point conversions
    State stdio equivalent
    floatfield == ios_base::fixed | ios_base::scientific && !uppercase%a
    floatfield == ios_base::fixed | ios_base::scientific%A
    
 
+
    
 
    
-These expressions are supposed to mean: 
+5 - These values are called past-the-end values. Values of an iterator i for
+which the expression *i is defined are called dereferenceable. The library
+never assumes that past-the-end values are dereferenceable. Iterators
+can also have singular values that are not associated with any
+container. [...] Results of most expressions are undefined for singular
+values; the only exceptions are destroying an iterator that holds a
+singular value and the assignment of a non-singular value to an iterator
+that holds a singular value. [...] Dereferenceable values are always
+non-singular.
 
    
 
-
    floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase 
-floatfield == (ios_base::fixed | ios_base::scientific) 
-
    
 
    
-but technically parsed as: 
+10 - An invalid iterator is an iterator that may be singular.
 
    
-
    ((floatfield == ios_base::fixed) | ios_base::scientific) && (!uppercase) 
-((floatfield == ios_base::fixed) | ios_base::scientific) 
-
    
+
    
+
 
    
-and should be corrected with additional parentheses, as shown above. 
+First, issue 208 intentionally removed the earlier constraint that past-the-end
+values are always non-singular. The reason for this was to support null
+pointers as past-the-end iterators of e.g. empty sequences. But there
+seem to exist different views on what a singular (iterator) value is. E.g.
+according to the SGI definition
+a null pointer is not a singular value:
 
    
 
+
    
+Dereferenceable iterators are always nonsingular, but the converse is
+not true.
+For example, a null pointer is nonsingular (there are well defined operations
+involving null pointers) even thought it is not dereferenceable.
+
    
 
-
    Proposed resolution:
    
 
    
-Change Table 73 — Floating-point conversions in  22.4.2.2.2 [facet.num.put.virtuals]:
+and proceeds:
 
    
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
    Table 73 — Floating-point conversions
    State stdio equivalent
    floatfield == (ios_base::fixed | ios_base::scientific) && !uppercase%a
    floatfield == (ios_base::fixed | ios_base::scientific)%A
    
-
-
-
-
-
-
    
-
    1153. Standard library needs review for constructors to be
-explicit to avoid treatment as initializer-list constructor
    
-
    Section: 17 [library], 30 [thread], D [depr] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-04
    
-
    View other active issues in [library].
    
-
    View all other issues in [library].
    
-
    View all issues with New status.
    
-
    Discussion:
    
-
-
    Addresses DE 2
    
-
-
    Description
    
-        
    Marking a constructor with explicit has semantics
-        even for a constructor with zero or several parameters:
-        Such a constructor cannot be used with list-initialization
-        in a copy-initialization context, see 13.3.1.7 [over.match.list]. The
-        standard library apparently has not been reviewed for
-        marking non-single-parameter constructors as explicit.
    
-
    Suggestion
    
-        
    Consider marking zero-parameter and multi-parameter
-        constructors explicit in classes that have at least one
-        constructor marked explicit and that do not have an
-        initializer-list constructor.
    
-
-
    Notes
    
-        
    Robert Klarer to address this one.
    
-
-
-
-
    Proposed resolution:
    
-
-
-
-
-
-
    
-
    1154. complex should accept integral types
    
-
    Section: 26.4 [complex.numbers] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-04
    
-
    View all other issues in [complex.numbers].
    
-
    View all issues with New status.
    
-
    Discussion:
    
-
-
    Addresses FR 35
    
-
-
    Description
    
-        
    Instantiations of the class
-        template complex<> have to be allowed for integral
-        types, to reflect existing practice and ISO standards
-        (LIA-III).
    
-        
-
    Suggestion
    
+
    
+An iterator is valid if it is dereferenceable or past-the-end.
+
    
 
+
    
+Even if the standard prefers a different meaning of singular here, the
+change was
+incomplete, because by restricting feasible expressions of singular
+iterators to
+destruction and assignment isn't sufficient for a past-the-end
+iterator: Of-course
+it must still be equality-comparable and in general be a readable value.
+
    
 
+
    
+Second, the standard doesn't clearly say whether a past-the-end value is
+a valid iterator or not. E.g. 20.8.13 [specialized.algorithms]/1 says:
+
    
 
-
    Proposed resolution:
    
+
    
+In all of the following algorithms, the formal template parameter
+ForwardIterator
+is required to satisfy the requirements of a forward iterator (24.1.3)
+[..], and is
+required to have the property that no exceptions are thrown from [..], or
+dereference of valid iterators.
+
    
 
+
    
+The standard should make better clear what "singular pointer" and "valid
+iterator" means. The fact that the meaning of a valid value
+has a core language meaning doesn't imply that for an iterator concept
+the term "valid iterator" has the same meaning.
+
    
 
+
    
+Let me add a final example: In X [allocator.concepts.members] of
+N2914
+we find:
+
    
 
+
    pointer X::allocate(size_type n);
+
    
 
+
    
+11 Returns: a pointer to the allocated memory. [Note: if n == 0, the return
+value is unspecified. —end note]
+
    
 
-
    
-
    1155. Reference should be to C99
    
-
    Section: C.2 [diff.library] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-25
    
-
    View other active issues in [diff.library].
    
-
    View all other issues in [diff.library].
    
-
    View all issues with New status.
    
-
    Discussion:
    
+
    
+[..]
+
    
 
-
    Addresses FR 38
    
+
    void X::deallocate(pointer p, size_type n);
+
    
 
-
    Description
    
-        
    What is ISO/IEC 1990:9899/DAM
-        1? My guess is that's a typo for ISO/IEC
-        9899/Amd.1:1995 which I'd
-        have expected to be referenced here (the tables
-        make reference to things
-        which were introduced by Amd.1).
    
-
    Suggestion
    
-        
    One need probably a reference
-        to the document which introduce char16_t and
-        char32_t in C (ISO/IEC TR 19769:2004?).
    
-
    Notes
    
-
    Create issue. Document in question should be C99, not C90+amendment1. The 
-    rest of the section requires careful review for completeness. Example <cstdint> 
-    18.4.1 [cstdint.syn]. Assign to C liasons.
    
+
    
+Preconditions: p shall be a non-singular pointer value obtained from a call
+to allocate() on this allocator or one that compares equal to it.
+
    
+
    
 
+
    
+If singular pointer value would include null pointers this make the
+preconditions
+unclear if the pointer value is a result of allocate(0): Since the return value
+is unspecified, it could be a null pointer. Does that mean that programmers
+need to check the pointer value for a null value before calling deallocate?
+
    
 
 
 
    Proposed resolution:
    
@@ -30002,205 +25735,227 @@ explicit to avoid treatment as initializer-list constructor
 
 
 
    
-
    1156. Constraints on bitmask and enumeration types to be tightened
    
-
    Section: 17.5.2.1.2 [enumerated.types], 17.5.2.1.3 [bitmask.types] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-25
    
+
    1214. Insufficient/inconsistent key immutability requirements for  associative containers
    
+
    Section: 23.2.4 [associative.reqmts] Status: New
+ Submitter: Daniel Krügler Opened: 2009-09-20  Last modified: 2009-09-20
    
+
    View other active issues in [associative.reqmts].
    
+
    View all other issues in [associative.reqmts].
    
 
    View all issues with New status.
    
 
    Discussion:
    
+
    
+Scott Meyers' mentions on a recent posting on c.s.c++
+some arguments that point to an incomplete resolution
+of 103 and to an inconsistency of requirements on keys in ordered and
+unordered associative
+containers:
+
    
 
-
    Addresses UK 165
    
-
-
    Description
    
-        
    Constraints on
-        bitmask and enumeration types were supposed to be tightened
-        up as part of the motivation for the constexpr feature -
-        see paper
-        N2235
-        for details
    
-
    Suggestion
    
-        
    Adopt wording in line with the motivation
-        described in
-        N2235
    
-
    Notes
    
-        
    Robert Klarer to review
    
-
-
-
-
    Proposed resolution:
    
-
-
+
    
+
    
+1) 103 introduced the term immutable without defining it in a unique manner in
+23.2.4 [associative.reqmts]/5:
+
    
 
+
    
+[..] Keys in an associative container are immutable.
+
    
 
+
    
+According to conventional dictionaries immutable is an unconditional way of
+saying that something cannot be changed. So without any further explicit
+allowance a user always runs into undefined behavior if (s)he attempts
+to modify such a key. IMO this was not the intend of the committee to resolve
+103 in that way because the comments suggest an interpretation that
+should give any user the freedom to modify the key in an explicit way
+provided it would not affect the sort order in that container.
+
    
 
-
    
-
    1157. Local types can now instantiate templates
    
-
    Section: 17.6.3.2.1 [namespace.std] Status: Review
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-28
    
-
    View all issues with Review status.
    
-
    Discussion:
    
+
    
+2) Another observation was that surprisingly no similar 'safety guards'
+exists against unintentional key changes for the unordered associative
+containers, specifically there is no such requirement as in
+23.2.4 [associative.reqmts]/6 that "both iterator and const_iterator are constant
+iterators". But the need for such protection against unintentional
+changes as well as the constraints in which manner any explicit
+changes may be performed are both missing and necessary, because
+such changes could potentially change the equivalence of keys that
+is measured by the hasher and key_equal.
+
    
 
-
    Addresses UK 175
    
+
    
+I suggest to fix the unconditional wording involved with "immutable keys"
+by at least adding a hint for the reader that users may perform such
+changes in an explicit manner and to perform similar wording changes
+as 103 did for the ordered associative containers also for the unordered
+containers.
+
    
+
    
 
-
    Description
    
-        
    Local types can
-        now be used to instantiate templates, but don't have
-        external linkage.
    
-
    Suggestion
    
-        
    Remove the reference to external linkage.
    
 
-
    Notes
    
-
    We accept the proposed solution. Martin will draft an issue.
    
+
    Proposed resolution:
    
 
-
    [
-2009-07-28 Alisdair provided wording.
-]
    
 
 
 
 
-
    Proposed resolution:
    
+
    
+
    1215. list::merge with unequal allocators
    
+
    Section: 23.3.4.4 [list.ops] Status: New
+ Submitter: Pablo Halpern Opened: 2009-09-24  Last modified: 2009-09-24
    
+
    View other active issues in [list.ops].
    
+
    View all other issues in [list.ops].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-17.6.3.2.1 [namespace.std]
+In Bellevue (I think), we passed
+N2525,
+which, among other things, specifies that the behavior of
+list::splice is undefined if the allocators of the two lists
+being spliced do not compare equal. The same rationale should apply to
+list::merge. The intent of list::merge (AFAIK) is to
+move nodes from one sorted list into another sorted
+list without copying the elements. This is possible only if the
+allocators compare equal.
 
    
+
+
+
    Proposed resolution:
    
 
    
-Strike "of external linkage" in p1 and p2:
+Relative to the August 2009 WP,
+N2857,
+change 23.3.4.4 [list.ops],
+paragraphs 22-25 as follows:
 
    
 
+
    
+
    void merge(list&& x);
+template <class Compare> void merge(list&& x, Compare comp);
+
    
 
    
 
    
--1- The behavior of a C++ program is undefined if it adds declarations or
-definitions to namespace std or to a namespace within namespace std
-unless otherwise specified. A program may add a concept map for any
-standard library concept or a template specialization for any standard
-library template to namespace std only if the declaration depends on a
-user-defined type of external linkage and the specialization meets the
-standard library requirements for the original template and is not
-explicitly prohibited.179
+Requires: both the list and the argument list shall be sorted
+according to operator< or comp.
 
    
-
 
    
--2- The behavior of a C++ program is undefined if it declares
+Effects: If (&x == this) does nothing; otherwise, merges the
+two sorted ranges [begin(), end()) and [x.begin(),
+x.end()). The result is a range in which the elements will be
+sorted in non-decreasing order according to the ordering defined by
+comp; that is, for every iterator i, in the range other than the
+first, the condition comp(*i, *(i - 1)) will be
+false.
 
    
-
      
-
    • 
-an explicit specialization of any member function of a standard library
-class template, or
-
      • 
-
    • 
-an explicit specialization of any member function template of a standard
-library class or class template, or
-
      • 
-
    • 
-an explicit or partial specialization of any member class template of a
-standard library class or class template.
-
      • 
-
    
 
    
-A program may explicitly instantiate a template defined in the standard
-library only if the declaration depends on the name of a user-defined
-type of external linkage and the instantiation meets the standard
-library requirements for the original template.
+Remarks: Stable. If (&x != this) the range [x.begin(), x.end()) is
+empty after the merge. No elements are copied by this operation.
+The behavior is undefined if this->get_allocator() !=
+x.get_allocator().
+
    
+
    
+Complexity: At most size() + x.size() - 1 applications of comp
+if (&x != this); otherwise, no applications of comp are performed. If an
+exception is thrown other than by a comparison there are no effects.
 
    
 
    
-
+
    
 
 
 
 
 
 
    
-
    1158. Encouragement to use monotonic clock
    
-
    Section: 30.2.4 [thread.req.timing] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-05
    
-
    View all issues with New status.
    
+
    1216. LWG 1066 Incomplete?
    
+
    Section: 18.8.6 [except.nested] Status: Ready
+ Submitter: Pete Becker Opened: 2009-09-25  Last modified: 2009-10-20
    
+
    View other active issues in [except.nested].
    
+
    View all other issues in [except.nested].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
+
    
+LWG 1066 adds [[noreturn]] to a bunch of things.
+It doesn't add it to rethrow_nested(), which seems like an obvious
+candidate. I've made the changes indicated in the issue, and haven't
+changed rethrow_nested().
+
    
 
-
    Addresses UK 322, US 96
    
+
    [
+2009 Santa Cruz:
+]
    
 
-
    Description
    
-        
    Not all systems
-        can provide a monotonic clock. How are they expected to
-        treat a _for function?
    
-
    Suggestion
    
-        
    Add at least a note explaining the intent
-        for systems that do not support a monotonic clock.
    
 
-
    Notes
    
-
    Create an issue, together with UK 96. Note that the specification as is 
-    already allows a non-monotonic clock due to the word “should” rather than 
-    “shall”. If this wording is kept, a footnote should be added to make the 
-    meaning clear.
    
+
    
+Move to Ready.
+
    
 
-
    [ 2009-06-29 Beman provided a proposed resolution. ] 
    
-    
 
 
 
    Proposed resolution:
    
+
    
+Add [[noreturn]] to rethrow_nested() in 18.8.6 [except.nested].
+
    
 
-
    Change Timing specifications 30.2.4 [thread.req.timing] as indicated:
    
 
-
    The member functions whose names end in _for take an argument that
-specifies a relative time. Implementations
-should are encouraged but not required to use a
-monotonic clock to measure time for these functions.
    
 
 
 
+
    
+
    1218. mutex destructor synchronization
    
+
    Section: 30.4.1 [thread.mutex.requirements] Status: New
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-09-30
    
+
    View other active issues in [thread.mutex.requirements].
    
+
    View all other issues in [thread.mutex.requirements].
    
+
    View all issues with New status.
    
+
    Discussion:
    
+
    
+If an object *o contains a mutex mu and a
+correctly-maintained reference count c, is the following code
+safe?
+
    
+
+
    o->mu.lock();
+bool del = (--(o->c) == 0);
+o->mu.unlock();
+if (del) { delete o; }
+
    
+
+
    
+If the implementation of mutex::unlock() can touch the mutex's
+memory after the moment it becomes free, this wouldn't be safe, and
+"Construction and destruction of an object of a Mutex type need not be
+thread-safe" 30.4.1 [thread.mutex.requirements] may imply that
+it's not safe. Still, it's useful to allow mutexes to guard reference
+counts, and if it's not allowed, users are likely to write bugs.
+
    
+
+
+
    Proposed resolution:
    
+
    
+
    
+
+
 
 
 
 
    
-
    1159. Unclear spec for resource_deadlock_would_occur
    
+
    1219. unique_lock::lock and resource_deadlock_would_occur
    
 
    Section: 30.4.3.2.2 [thread.lock.unique.locking] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-04
    
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-09-30
    
 
    View other active issues in [thread.lock.unique.locking].
    
 
    View all other issues in [thread.lock.unique.locking].
    
 
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses UK 327, UK 328
    
-
-
    UK 327 Description
    
-        
    Not clear what
-        the specification for error condition
-        resource_deadlock_would_occur means. It is perfectly
-        possible for this thread to own the mutex without setting
-        owns to true on this specific lock object. It is also
-        possible for lock operations to succeed even if the thread
-        does own the mutex, if the mutex is recursive. Likewise, if
-        the mutex is not recursive and the mutex has been locked
-        externally, it is not always possible to know that this
-        error condition should be raised, depending on the host
-        operating system facilities. It is possible that 'i.e.' was
-        supposed to be 'e.g.' and that suggests that recursive
-        locks are not allowed. That makes sense, as the
-        exposition-only member owns is boolean and not a integer to
-        count recursive locks.
    
-        
-
    UK 327 Suggestion
    
-        
    Add a precondition !owns. Change the 'i.e.'
-        in the error condition to be 'e.g.' to allow for this
-        condition to propogate deadlock detection by the host OS.
    
-
    UK 327 Notes
    
-
    Create an issue. Assigned to Lawrence Crowl. Note: not sure what try_lock 
-    means for recursive locks when you are the owner. POSIX has language on 
-    this, which should ideally be followed. Proposed fix is not quite right, for 
-    example, try_lock should have different wording from lock.
    
-
-
    UK 328 Description
    
-
-        
    There is a missing precondition that owns
-        is true, or an if(owns) test is missing from the effect
-        clause
    
-
    UK 328 Suggestion
    
-        
    Add a
-        precondition that owns == true. Add an error condition to
-        detect a violation, rather than yield undefined behaviour.
    
-
    UK 328 Notes
    
-
    Handle in same issue as UK 327. Also uncertain that the proposed resolution 
-    is the correct one.
    
-
-    
+
    
+unique_lock::lock and friends raise
+"resource_deadlock_would_occur -- if the current thread already
+owns the mutex (i.e., on entry, owns is true)."  1)
+The current thread owning a mutex is not the same as any particular
+unique_lock::owns being true. 2) There's no need to
+raise this exception for a recursive_mutex if owns is
+false. 3) If owns is true, we need to raise some
+exception or the unique_lock will lose track of whether to unlock itself
+on destruction, but "deadlock" isn't it. For (3), s/bool owns/int
+ownership_level/ would fix it.
+
    
 
 
 
    Proposed resolution:
    
@@ -30210,86 +25965,79 @@ monotonic clock to measure time for these functions.
    
 
 
 
    
-
    1160. future_error public constructor is 'exposition only'
    
-
    Section: 30.6.3 [futures.future_error] Status: Open
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
    
-
    View all issues with Open status.
    
+
    1220. What does condition_variable wait on?
    
+
    Section: 30.5 [thread.condition] Status: Tentatively Ready
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-11-06
    
+
    View other active issues in [thread.condition].
    
+
    View all other issues in [thread.condition].
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
-
-
    Addresses UK 331
    
-
-
    Description
    
-        
    Not clear what
-        it means for a public constructor to be 'exposition only'.
-        If the intent is purely to support the library calling this
-        constructor then it can be made private and accessed
-        through friendship. Otherwise it should be documented for
-        public consumption.
    
-
    Suggestion
    
-        
    Declare the constructor as private with a
-        note about intended friendship, or remove the
-        exposition-only comment and document the semantics.
    
-
    Notes
    
-
    Create an issue. Assigned to Detlef. Suggested resolution probably makes 
-    sense.
    
+
    
+"Class condition_variable provides a condition variable that can only
+wait on an object of type unique_lock" should say "...object of type
+unique_lock<mutex>"
+
    
 
 
    [
-2009-07 Frankfurt
+2009-11-06 Howard adds:
 ]
    
 
 
 
    
-Pending a paper from Anthony Williams / Detleff Volleman.
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.
 
    
 
 
 
 
    Proposed resolution:
    
+
    
+Change 30.5 [thread.condition], p1:
+
    
+
+
    
+Condition variables provide synchronization primitives used to block a
+thread until notified by some other thread that some condition is met or
+until a system time is reached. Class condition_variable
+provides a condition variable that can only wait on an object of type
+unique_lock<mutex>, allowing maximum
+efficiency on some platforms. Class condition_variable_any
+provides a general condition variable that can wait on objects of
+user-supplied lock types.
+
    
 
 
 
 
 
 
    
-
    1161. Unnecessary unique_future limitations
    
-
    Section: 30.6.5 [futures.unique_future] Status: Open
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
    
-
    View other active issues in [futures.unique_future].
    
-
    View all other issues in [futures.unique_future].
    
-
    View all issues with Open status.
    
+
    1221. condition_variable wording
    
+
    Section: 30.5.1 [thread.condition.condvar] Status: New
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-09-30
    
+
    View other active issues in [thread.condition.condvar].
    
+
    View all other issues in [thread.condition.condvar].
    
+
    View all issues with New status.
    
 
    Discussion:
    
+
    
+30.5.1 [thread.condition.condvar] says:
+
    
 
-
    Addresses UK 336
    
-
-
    Description
    
-
-        
    It is possible
-        to transfer ownership of the asynchronous result from one
-        unique_future instance to another via the move-constructor.
-        However, it is not possible to transfer it back, and nor is
-        it possible to create a default-constructed unique_future
-        instance to use as a later move target. This unduly limits
-        the use of unique_future in code. Also, the lack of a
-        move-assignment operator restricts the use of unique_future
-        in containers such as std::vector - vector::insert requires
-        move-assignable for example.
    
-
    Suggestion
    
-        
    Add a default constructor with the
-        semantics that it creates a unique_future with no
-        associated asynchronous result. Add a move-assignment
-        operator which transfers ownership.
    
-
    Notes
    
-
    Create an issue. Detlef will look into it.
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
 
    
-Pending a paper from Anthony Williams / Detleff Volleman.
+
    ~condition_variable();
+
    
+
    
+Precondition: There shall be no thread blocked on *this.
+[Note: That is, all threads shall have been notified; they may
+subsequently block on the lock specified in the wait. Beware that
+destroying a condition_variable object while the corresponding
+predicate is false is likely to lead to undefined behavior.
+— end note]
+
    
 
    
 
+
    
+The text hasn't introduced the notion of a "corresponding predicate"
+yet.
+
    
 
 
 
    Proposed resolution:
    
@@ -30299,35 +26047,90 @@ Pending a paper from Anthony Williams / Detleff Volleman.
 
 
 
    
-
    1162. shared_future should support an efficient move constructor
    
-
    Section: 30.6.6 [future.shared_future] Status: Open
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
    
-
    View other active issues in [future.shared_future].
    
-
    View all other issues in [future.shared_future].
    
-
    View all issues with Open status.
    
+
    1222. condition_variable incorrect effects for exception safety
    
+
    Section: 30.5 [thread.condition] Status: New
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-09-30
    
+
    View other active issues in [thread.condition].
    
+
    View all other issues in [thread.condition].
    
+
    View all issues with New status.
    
 
    Discussion:
    
+
    
+30.5.1 [thread.condition.condvar] says:
+
    
 
-
    Addresses UK 337
    
+
    
+
    void wait(unique_lock<mutex>& lock);
+
    
+
    
+
    ...
    
+
    
+Effects:
+
    
+
      
+
    • ...
      • 
+
    • 
+If the function exits via an exception, lock.unlock() shall be
+called prior to exiting the function scope.
+
      • 
+
    
+
    
+
    
 
-
    Description
    
-        
    shared_future
-        should support an efficient move constructor that can avoid
-        unnecessary manipulation of a reference count, much like
-        shared_ptr
    
-
    Suggestion
    
-        
    Add a move constructor
    
-
    Notes
    
-
    Create an issue. Detlef will look into it.
    
+
    
+Should that be lock.lock()?
+
    
 
-
    [
-2009-07 Frankfurt
-]
    
 
+
    Proposed resolution:
    
+
+
    
+Change 30.5.1 [thread.condition.condvar] p10:
+
    
 
 
    
-Pending a paper from Anthony Williams / Detleff Volleman.
+
    void wait(unique_lock<mutex>& lock);
+
    
+
    
+
    ...
    
+
    
+Effects:
+
    
+
      
+
    • ...
      • 
+
    • 
+If the function exits via an exception, lock.unlock() shall be
+called prior to exiting the function scope.
+
      • 
+
    
+
    
 
    
 
+
    
+And make a similar change in p16, and in 30.5.2 [thread.condition.condvarany],
+p8 and p13.
+
    
+
+
+
+
+
+
+
    
+
    1223. condition_variable_any lock matching?
    
+
    Section: 30.5.2 [thread.condition.condvarany] Status: New
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-09-30
    
+
    View other active issues in [thread.condition.condvarany].
    
+
    View all other issues in [thread.condition.condvarany].
    
+
    View all issues with New status.
    
+
    Discussion:
    
+
    
+For condition_variable_any, must all lock arguments to concurrent wait calls
+"match" in some way, similar to the requirement in
+30.5.1 [thread.condition.condvar] that lock.mutex() returns the same
+value for each of the lock arguments supplied by all concurrently
+waiting threads (via wait or timed_wait)?
+
    
+
 
 
 
    Proposed resolution:
    
@@ -30337,52 +26140,16 @@ Pending a paper from Anthony Williams / Detleff Volleman.
 
 
 
    
-
    1163. shared_future is inconsistent with shared_ptr
    
-
    Section: 30.6.6 [future.shared_future] Status: Open
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
    
-
    View other active issues in [future.shared_future].
    
-
    View all other issues in [future.shared_future].
    
-
    View all issues with Open status.
    
+
    1224. condition_variable_any support for recursive mutexes?
    
+
    Section: 30.5.2 [thread.condition.condvarany] Status: New
+ Submitter: Jeffrey Yasskin Opened: 2009-09-30  Last modified: 2009-09-30
    
+
    View other active issues in [thread.condition.condvarany].
    
+
    View all other issues in [thread.condition.condvarany].
    
+
    View all issues with New status.
    
 
    Discussion:
    
-
-
    Addresses UK 338
    
-
-
    Description
    
-
-        
    shared_future is currently
-        CopyConstructible, but not CopyAssignable. This is
-        inconsistent with shared_ptr, and will surprise users.
-        Users will then write work-arounds to provide this
-        behaviour. We should provide it simply and efficiently as
-        part of shared_future. Note that since the shared_future
-        member functions for accessing the state are all declared
-        const, the original usage of an immutable shared_future
-        value that can be freely copied by multiple threads can be
-        retained by declaring such an instance as "const
-        shared_future".
    
-
    Suggestion
    
-        
    Remove "=delete"
-        from the copy-assignment operator of shared_future. Add a
-        move-constructor shared_future(shared_future&&
-        rhs), and a move-assignment operator shared_future&
-        operator=(shared_future&& rhs). The postcondition
-        for the copy-assignment operator is that *this has the same
-        associated state as rhs. The postcondition for the
-        move-constructor and move assignment is that *this has the
-        same associated as rhs had before the
-        constructor/assignment call and that rhs has no associated
-        state.
    
-
    Notes
    
-
    Create an issue. Detlef will look into it.
    
-
-
    [
-2009-07 Frankfurt
-]
    
-
-
-
    
-Pending a paper from Anthony Williams / Detleff Volleman.
-
    
+
    
+For condition_variable_any, are recursive mutexes allowed? (I think "no")
+
    
 
 
 
@@ -30393,485 +26160,516 @@ Pending a paper from Anthony Williams / Detleff Volleman.
 
 
 
    
-
    1165. Unneeded promise move constructor
    
-
    Section: 30.6.4 [futures.promise] Status: Open
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
    
-
    View other active issues in [futures.promise].
    
-
    View all other issues in [futures.promise].
    
-
    View all issues with Open status.
    
+
    1225. C++0x result_of issue 
    
+
    Section: 20.7.4 [func.ret] Status: New
+ Submitter: Sebastian Gesemann Opened: 2009-10-05  Last modified: 2009-10-17
    
+
    View all other issues in [func.ret].
    
+
    View all issues with New status.
    
 
    Discussion:
    
+
    
+I think the text about std::result_of could be a little more precise.
+Quoting from
+N2960...
+
    
 
-
    Addresses UK 343
    
-
-
    Description
    
-        
    The move constructor of a std::promise
-        object does not need to allocate any memory, so the
-        move-construct-with-allocator overload of the constructor
-        is superfluous.
    
-
    Suggestion
    
-        
    Remove the
-        constructor with the signature template <class
-        Allocator> promise(allocator_arg_t, const Allocator&
-        a, promise& rhs);
    
-
    Notes
    
-
    Create an issue. Detlef will look into it. Will solicit feedback from Pablo. 
-    Note that “rhs” argument should also be an rvalue reference in any case.
    
+
    
+
    
+20.7.4 [func.ret] Function object return types
+
    
 
-
    [
-2009-07 Frankfurt
-]
    
+
    template<class> class result_of;
 
+template<class Fn, class... ArgTypes>
+class result_of<Fn(ArgTypes...)> {
+public:
+  typedef see below type;
+};
+
    
 
-
    
-Pending a paper from Anthony Williams / Detleff Volleman.
+
    
+Given an rvalue fn of type Fn and values t1, t2,
+..., tN of types T1, T2, ... TN in ArgTypes
+respectivly, the type member is the result type of the
+expression fn(t1,t2,...,tN). the values ti are lvalues
+when the corresponding type Ti is an lvalue-reference type, and
+rvalues otherwise.
+
    
 
    
 
+
    
+This text doesn't seem to consider lvalue reference types for Fn.
+Also, it's not clear whether this class template can be used for
+"SFINAE" like std::enable_if. Example:
+
    
 
+
    template<typename Fn, typename... Args>
+typename std::result_of<Fn(Args...)>::type
+apply(Fn && fn, Args && ...args)
+{
+  // Fn may be an lvalue reference, too
+  return std::forward<Fn>(fn)(std::forward<Args>(args)...);
+}
+
    
 
-
    Proposed resolution:
    
+
    
+Either std::result_of<...> can be instantiated and simply may not have
+a typedef "type" (-->SFINAE) or instantiating the class template for
+some type combinations will be a "hard" compile-time error.
+
    
 
 
+
    Proposed resolution:
    
 
+
    [
+These changes will require compiler support
+]
    
 
 
-
    
-
    1166. Allocator-specific move/copy break model of move-constructor and
-        move-assignment
    
-
    Section: X [allocator.propagation], X [allocator.propagation.map], 23 [containers] Status: New
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-04
    
-
    View all issues with New status.
    
-
    Discussion:
    
+
    
+Change 20.7.4 [func.ret]:
+
    
 
-
    Addresses US 77
    
+
    template<class> class result_of; // undefined
 
-
    Description
    
-        
    Allocator-specific move and copy behavior for containers
-        (N2525) complicates a little-used and already-complicated
-        portion of the standard library (allocators), and breaks
-        the conceptual model of move-constructor and
-        move-assignment operations on standard containers being
-        efficient operations. The extensions for allocator-specific
-        move and copy behavior should be removed from the working
-        paper.
    
-        
    With the
-        introduction of rvalue references, we are teaching
-        programmers that moving from a standard container (e.g., a
-        vector<string>) is an efficient, constant-time
-        operation. The introduction of N2525 removed that
-        guarantee; depending on the behavior of four different
-        traits (20.8.4), the complexity of copy and move operations
-        can be constant or linear time. This level of customization
-        greatly increases the complexity of standard containers,
-        and benefits only a tiny fraction of the C++ community.
    
-
    Suggestion
    
+template<class Fn, class... ArgTypes>
+class result_of<Fn(ArgTypes...)> {
+public:
+  typedef see below type;
+};
+
    
 
-        
    Remove 20.8.4.
    
-        
-        
    Remove 20.8.5.
    
-        
-        
    Remove all references to the facilities in
-        20.8.4 and 20.8.5 from clause 23.
    
+
    
+Given an rvalue fn of type Fn and values t1, t2,
+..., tN of types T1, T2, ... TN in ArgTypes
+respectivly, the type member is the result type of the
+expression fn(t1,t2,...,tN). the values ti are lvalues
+when the corresponding type Ti is an lvalue-reference type, and
+rvalues otherwise.
+
    
+
+
    
+The class template result_of shall meet the requirements of a
+TransformationTrait: Given the types Fn, T1, T2, ..., TN every
+template specialization result_of<Fn(T1,T2,...,TN)> shall define the
+member typedef type equivalent to decltype(RE) if and only if
+the expression RE
+
    
 
+
    
+value<Fn>() ( value<T1>(), value<T2>(), ... value<TN>()  )
+
    
 
+
    
+would be well-formed. Otherwise, there shall be no member typedef
+type defined.
+
    
 
+
    
+ 
+
    [
+The value<> helper function is a utility Daniel Krügler
+proposed in
+N2958.
+]
    
 
-
    Proposed resolution:
    
 
 
 
 
 
 
    
-
    1169. num_get not fully compatible with strto*
    
-
    Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: New
- Submitter: Cosmin Truta Opened: 2009-07-04  Last modified: 2009-07-07
    
-
    View other active issues in [facet.num.get.virtuals].
    
-
    View all other issues in [facet.num.get.virtuals].
    
-
    View all issues with New status.
    
+
    1226. Incomplete changes of #890
    
+
    Section: 30.6.2 [futures.errors] Status: Tentatively Ready
+ Submitter: Daniel Krügler Opened: 2009-10-05  Last modified: 2009-10-27
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
    
-As specified in the latest draft,
-N2914,
-num_get is still not fully compatible with the following C
-functions: strtoul, strtoull, 
-strtof and
-strtod.
-
    
-
    
-In C, when conversion of a string to an unsigned integer type falls 
-outside the
-representable range, strtoul and strtoull return
-ULONG_MAX and ULLONG_MAX, respectively, 
-regardless
-whether the input field represents a positive or a negative value.
-On the other hand, the result of num_get conversion of 
-negative
-values to unsigned integer types is zero. This raises a compatibility 
-issue.
-
    
-
    
-Moreover, in C, when conversion of a string to a floating-point type falls
-outside the representable range, strtof, strtod 
-and
-strtold return ąHUGE_VALF,
-ąHUGE_VAL and ąHUGE_VALL, respectively.
-On the other hand, the result of num_get conversion of such
-out-of-range floating-point values results in the most positive/negative
-representable value.
-Although many C library implementations do implement HUGE_VAL
-(etc.) as the highest representable (which is, usually, the infinity), 
-this
-isn't required by the C standard. The C library specification makes no
-statement regarding the value of HUGE_VAL and friends, which
-potentially raises the same compatibility issue as in the above case of
-unsigned integers.
-In addition, neither C nor C++ define symbolic constants for the maximum
-representable floating-point values (they only do so only for the maximum
-representable finite floating-point values), which raises a 
-usability
-issue (it would be hard for the programmer to check the result of
-num_get against overflow).
+Defect issue 890 overlooked to adapt the future_category from
+30.6.1 [futures.overview] and 30.6.2 [futures.errors]:
 
    
+
+
    extern const error_category* const future_category;
+
    
+
 
    
-As such, we propose to adjust the specification of num_get to
-closely follow the behavior of all of its underlying C functions.
+which should be similarly transformed into function form.
 
    
 
+
    [
+2009-10-27 Howard:
+]
    
+
+
+
    
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.
+
    
 
-
    Proposed resolution:
    
 
+
+
    Proposed resolution:
    
+
      
+
    1. 
 
      
-Change 22.4.2.1.2 [facet.num.get.virtuals] as follows:
+Change in 30.6.1 [futures.overview], header <future> synopsis:
 
      
-
      
+
+
      extern const error_category&* const future_category();
+
      
+
      2. 
+
+
    2. 
 
      
-Stage 3:
-The sequence of chars accumulated in stage 2 (the field) is
-converted to a numeric value by the rules of one of the functions declared in
-the header <cstdlib>:
+Change in 30.6.2 [futures.errors]:
 
      
-
        
-
      • For a signed integer value, the function strtoll.
        • 
-
      • For an unsigned integer value, the function strtoull.
        • 
-
      • For a float value, the function
-    strtof.
        • 
-
      • For a double value, the function
-    strtod.
        • 
-
      • For a floating-point long double
-    value, the function strtold.
        • 
-
      
+
+
      extern const error_category&* const future_category();
+
      
+
+
      
 
      
-The numeric value to be stored can be one of:
+1- future_category shall point to a statically initialized object
+of a type derived from class error_category.
 
      
-
        
-
      • zero, if the conversion function fails to convert the entire field.
-    ios_base::failbit is assigned to err.
        • 
-
      • the most positive (or negative) representable value, if
-    the field to be converted to a signed integer type represents a
-    value too large positive (or negative) to be represented in
-    val.
-    ios_base::failbit is assigned to err.
        • 
-
      • the most negative representable value or zero for an unsigned integer
-    type, if the field represents a value too large negative to be represented
-    in val.
-    ios_base::failbit is assigned to err.
        • 
-
      • the most positive representable value, if the field to be converted to
-    an unsigned integer type represents a value that cannot be represented in
-    val.
        • 
-
      • the converted value, otherwise.
        • 
-
      
 
      
-The resultant numeric value is stored in val.
-If the conversion function fails to convert the entire field, or if the
-field represents a value outside the range of representable values,
-ios_base::failbit is assigned to err.
+1- Returns: A reference to an object of a type
+derived from class error_category.
 
      
 
      
 
+
      constexpr error_code make_error_code(future_errc e);
+
      
+
+
      
+3 Returns: error_code(static_cast<int>(e),
+*future_category()).
+
      
+
+
      constexpr error_code make_error_condition(future_errc e);
+
      
+
+
      
+4 Returns: error_condition(static_cast<int>(e),
+*future_category()).
+
      
+
      
+
      3. 
+
    
 
 
 
 
 
 
    
-
    1170. String char-like types no longer PODs
    
-
    Section: 21.1 [strings.general] Status: New
- Submitter: Beman Dawes Opened: 2009-06-22  Last modified: 2009-07-28
    
-
    View all issues with New status.
    
+
    1227. <bitset> synopsis overspecified
    
+
    Section: 20.3.7 [template.bitset] Status: Ready
+ Submitter: Bo Persson Opened: 2009-10-05  Last modified: 2009-10-26
    
+
    View other active issues in [template.bitset].
    
+
    View all other issues in [template.bitset].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
-
-
    Prior to the introduction of constant expressions into the library, 
-basic_string elements had to be POD types, and thus had to be both trivially 
-copyable and standard-layout. This ensured that they could be memcpy'ed and 
-would be compatible with other libraries and languages, particularly the C 
-language and its library.
    
 
    
-N2349,
-Constant Expressions in the Standard Library Revision 2, changed the 
-requirement in 21/1 from "POD type" to "literal type". That change had the 
-effect of removing the trivially copyable and standard-layout requirements from 
-basic_string elements.
    
-
    This means that basic_string elements no longer are guaranteed to be 
-memcpy'able, and are no longer guaranteed to be standard-layout types:
    
-
    
-  
    3.9/p2 and 3.9/p3 both make it clear that a "trivially copyable type" is 
-  required for memcpy to be guaranteed to work.
    
-  
    Literal types (3.9p12) may have a non-trivial copy assignment operator, and 
-  that violates the trivially copyable requirements given in 9/p 6, bullet item 
-  2. 
    
-  
    Literal types (3.9p12) have no standard-layout requirement, either.
    
-
    
-
    This situation probably arose because the wording for "Constant Expressions 
-in the Standard Library" was in process at the same time the C++ POD 
-deconstruction wording was in process. 
    
-
    Since trivially copyable types meet the C++0x requirements for literal types, 
-and thus work with constant expressions, it seems an easy fix to revert the 
-basic_string element wording to its original state.
    
+The resolutions to some library defect reports, like 1178
+requires that #includes in each synopsis should be taken
+literally. This means that the <bitset> header now
+must include <stdexcept>, even though none of the
+exceptions are mentioned in the <bitset> header.
+
    
+
    
+Many other classes are required to throw exceptions like
+invalid_argument and out_of_range, without explicitly
+including <stdexcept> in their synopsis. It is totally
+possible for implementations to throw the needed exceptions from utility
+functions, whose implementations are not visible in the headers.
+
    
+
    
+I propose that <stdexcept> is removed from the
+<bitset> header.
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
 
- 
    [
- 2009-07-28 Alisdair adds:
- ]
    
 
- 
 
    
-When looking for any resolution for this issue, consider the definition of
-"character container type" in 17.3.4 [defns.character.container].  This
-does require the character type to be a POD, and this term is used in a
-number of places through clause 21 and 28. This suggests the PODness
-constraint remains, but is much more subtle than before.  Meanwhile, I
-suspect the change from POD type to literal type was intentional with
-the assumption that trivially copyable types with
-non-trivial-but-constexpr constructors should serve as well.  I don't
-believe the current wording offers the right guarantees for either of
-the above designs.
+Moved to Ready.
 
    
 
 
 
 
    Proposed resolution:
    
+
    
+Change 20.3.7 [template.bitset]:
+
    
 
-
    Change General 21.1 [strings.general] as indicated:
    
-
    
-
    This Clause describes components for manipulating sequences of any literal POD 
-(3.9) type. In this Clause
-such types are called char-like types, and objects of char-like types are 
-called char-like objects or simply characters.
    
-
    
-
+
    #include <cstddef>        // for size_t
+#include <string>
+#include <stdexcept>      // for invalid_argument,
+                          // out_of_range, overflow_error
+#include <iosfwd>         // for istream, ostream
+namespace std {
+...
+
    
 
 
 
 
 
 
    
-
    1171. duration types shoud be literal
    
-
    Section: 20.9.3 [time.duration] Status: New
- Submitter: Alisdair Meredith Opened: 2009-07-06  Last modified: 2009-07-07
    
-
    View other active issues in [time.duration].
    
-
    View all other issues in [time.duration].
    
-
    View all issues with New status.
    
+
    1228. User-specialized nothrow type traits
    
+
    Section: 20.6.4.3 [meta.unary.prop] Status: Open
+ Submitter: Alisdair Meredith Opened: 2009-10-07  Last modified: 2009-10-26
    
+
    View other active issues in [meta.unary.prop].
    
+
    View all other issues in [meta.unary.prop].
    
+
    View all issues with Open status.
    
 
    Discussion:
    
 
    
-The duration types in 20.9.3 [time.duration] are exactly the sort of type
-that should be "literal types" in the new standard.  Likewise,
-arithmetic operations on durations should be declared constexpr.
-
    
-
-
-
    Proposed resolution:
    
-
    
-Add constexpr to declaration of following functions and constructors:
-
    
-
    
-p1 20.9 [time]
+According to p1 20.6.2 [meta.type.synop]:
 
    
 
 
    
+The behavior of a program that adds specializations for any of the class
+templates defined in this subclause is undefined unless otherwise
+specified.
+
    
+
 
    
-Header <chrono> synopsis
+I believe we should 'otherwise specify' for the nothrow traits, are
+these are exactly the use cases where the end user actually has more
+information than the compiler.
 
    
 
-
    [Draughting note - observe switch to pass-by-value to support constexpr]
    
+
    [
+2009-10 Santa Cruz:
+]
    
 
 
-
    // duration arithmetic
-template <class Rep1, class Period1, class Rep2, class Period2>
-   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
-   constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
-   constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period, class Rep2>
-   duration<typename common_type<Rep1, Rep2>::type, Period>
-   constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
-template <class Rep1, class Period, class Rep2>
-   duration<typename common_type<Rep1, Rep2>::type, Period>
-   constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
-template <class Rep1, class Period, class Rep2>
-   duration<typename common_type<Rep1, Rep2>::type, Period>
-   constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   typename common_type<Rep1, Rep2>::type
-   constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
    
+Moved to Open.  Definitely need to give the users the ability to ensure
+that the traits give the right answers. Unsure we want to give them the
+ability to say this in more than one way. Believes the noexcept proposal
+already gives this.
+
    
 
-// duration comparisons
-template <class Rep1, class Period1, class Rep2, class Period2>
-   constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   constexpr bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   constexpr bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
-template <class Rep1, class Period1, class Rep2, class Period2>
-   constexpr bool operator>=(const  duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 
-// duration_cast
-template <class ToDuration, class Rep, class Period>
-   constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
-
    
 
+
    Proposed resolution:
    
 
    
-20.9.3 [time.duration]
+Add the following comment:
 
    
 
-
    template <class Rep, class Period = ratio<1>>
-class duration {
-  ....
-public:
-  // 20.9.3.1, construct/copy/destroy:
- constexpr duration() = default;
-
- template <class Rep2>
-   constexpr explicit duration(const Rep2& r);
- template <class Rep2, class Period2>
-   constexpr duration(const duration<Rep2, Period2>& d);
-
-  constexpr duration(const duration&) = default;
-
-  // 20.9.3.2, observer:
-  constexpr rep count() const;
+
    
+user specialization permitted to derive from std::true_type when the
+operation is known not to throw.
+
    
 
-  // 20.9.3.3, arithmetic:
-  constexpr duration operator+() const;
-  constexpr duration operator-() const;
-  ...
+
    
+to the following traits in 20.6.4.3 [meta.unary.prop] Table 43 Type
+property predicates.
+
    
 
-};
-
    
-
    
 
    [
-Note - this edit already seems assumed by definition of the duration static members zero/min/max.
-They cannot meaningfully be constexpr without this change.
+This may require a new Comments column
 ]
    
 
 
+
    has_nothrow_default_constructor
+has_nothrow_copy_constructor
+has_nothrow_assign
+
    
+
 
 
 
 
 
    
-
    1172. select_on_container_(copy|move)_construction over-constrained
    
-
    Section: 20.8.2.4 [allocator.concepts.members] Status: New
- Submitter: Alberto Ganesh Barbati Opened: 2009-07-08  Last modified: 2009-07-14
    
-
    View all issues with New status.
    
+
    1231. weak_ptr comparisons incompletely resolved
    
+
    Section: 20.8.15.3.5 [util.smartptr.weak.obs] Status: Tentatively Ready
+ Submitter: Daniel Krügler Opened: 2009-10-10  Last modified: 2009-11-06
    
+
    View all issues with Tentatively Ready status.
    
 
    Discussion:
    
 
    
-I believe the two functions
-select_on_container_(copy|move)_construction() are over-constrained. For
-example, the return value of the "copy" version is (see
-20.8.2.4 [allocator.concepts.members]/21):
+The
+n2637
+paper suggested several updates of the ordering semantics of
+shared_ptr
+and weak_ptr, among those the explicit comparison operators of weak_ptr were
+removed/deleted, instead a corresponding functor owner_less was added.
+The problem
+is that
+n2637
+did not clearly enough specify, how the previous wording
+parts describing
+the comparison semantics of weak_ptr should be removed.
 
    
+
+
    [
+2009-11-06 Howard adds:
+]
    
+
+
 
    
-Returns: x if the allocator should propagate from the existing
-container to the new container on copy construction, otherwise X().
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.
 
    
+
+
+
+
    Proposed resolution:
    
+
      
+
    1. 
 
      
-Consider the case where a user decides to provide an explicit concept
-map for Allocator to adapt some legacy allocator class, as he wishes to
-provide customizations that the LegacyAllocator concept map template
-does not provide.  Now, although it's true that the legacy class is
-required to have a default constructor, the user might have reasons to
-prefer a different constructor to implement
-select_on_container_copy_construction(). However, the current wording
-requires the use of the default constructor.
+Change 20.8.15.3 [util.smartptr.weak]/2 as described, the intention is to fix
+the now no longer valid
+requirement that weak_ptr is LessComparable [Note the deleted comma]:
 
      
+
+
      
+Specializations of weak_ptr shall be CopyConstructible,
+and CopyAssignable,
+and LessThanComparable, allowing their use in standard containers.
+
      
+
      2. 
+
+
    2. 
 
      
-Moreover, it's not said explicitly that x is supposed to be the
-allocator of the existing container. A clarification would do no harm.
+In 20.8.15.3.5 [util.smartptr.weak.obs] remove the paragraphs 9-11 including prototype:
 
      
 
+
      
+template<class T, class U> bool operator<(const weak_ptr<T>& a, const weak_ptr<U>& b);
+
+
      
+Returns: an unspecified value such that
+
      
+
        
+
      • 
+operator< is a strict weak ordering as described in 25.4;
+
        • 
+
      • 
+under the equivalence relation defined by operator<, !(a
+< b) && !(b < a), two weak_ptr instances are
+equivalent if and only if they share ownership or are both empty.
+
        • 
+
      
 
-
      Proposed resolution:
      
 
      
-Replace 20.8.2.4 [allocator.concepts.members]/21 with:
+Throws: nothing.
 
      
 
-
      X select_on_container_copy_construction(const X& x);
-
      
 
      
--21- Returns: x if the allocator should propagate from the existing
-container to the new container on copy construction, otherwise X().
-an allocator object to be used by the new container on copy
-construction. [Note: x is the allocator of the existing container that
-is being copied. The most obvious choices for the return value are x, if
-the allocator should propagate from the existing container, and X().
-— end note]
+[Note: Allows weak_ptr objects to be used as keys in associative
+containers. — end note]
 
      
 
      
+
      3. 
+
    
+
+
+
 
+
+
    
+
    1233. Missing unique_ptr signatures in synopsis
    
+
    Section: 20.8 [memory] Status: Tentatively NAD Editorial
+ Submitter: Daniel Krügler Opened: 2009-10-11  Last modified: 2009-11-04
    
+
    View all other issues in [memory].
    
+
    View all issues with Tentatively NAD Editorial status.
    
+
    Discussion:
    
 
    
-Replace 20.8.2.4 [allocator.concepts.members]/25 with:
+Related to 296.  Some unique_ptr signatures are missing
+from the synopsis in 20.8 [memory].
 
    
 
-
    X select_on_container_move_construction(X&& x);
-
    
+
    [
+2009-11-04 Howard adds:
+]
    
+
+
+
    
+Moved to Tentatively NAD Editorial.  The editor has adopted the fix.
+
    
+
+
+
    Proposed resolution:
    
 
    
--25- Returns: move(x) if the allocator should propagate from the existing
-container to the new container on move construction, otherwise X().
-an allocator object to be used by the new container on move
-construction. [Note: x is the allocator of the existing container that
-is being moved. The most obvious choices for the return value are move(x), if
-the allocator should propagate from the existing container, and X().
-— end note]
+Add in 20.8 [memory], Header <memory> synopsis
+missing declarations as shown below:
 
    
-
    
 
+
    // 20.8.11 Class unique_ptr:
+template <class X> class default_delete;
+template<class T> struct default_delete<T[]>;
+template <class X, class D = default_delete<T>> class unique_ptr;
+template<class T, class D> class unique_ptr<T[], D>;
+
+template<class T, class D> void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y);
+
+template<class T1, class D1, class T2, class D2>
+bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator!=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator<(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator<=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+template<class T1, class D1, class T2, class D2>
+bool operator>=(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);
+
    
 
 
 
 
 
 
    
-
    1173. "Equivalence" wishy-washiness
    
-
    Section: 17 [library] Status: New
- Submitter: David Abrahams Opened: 2009-07-14  Last modified: 2009-07-14
    
-
    View other active issues in [library].
    
-
    View all other issues in [library].
    
+
    1234. "Do the right thing" and NULL
    
+
    Section: 23.2.3 [sequence.reqmts] Status: New
+ Submitter: Matt Austern Opened: 2009-10-09  Last modified: 2009-10-13
    
+
    View other active issues in [sequence.reqmts].
    
+
    View all other issues in [sequence.reqmts].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-Issue: The CopyConstructible requirements are wishy-washy.  It requires
-that the copy is "equivalent" to the original, but "equivalent" is never
-defined.
+On g++ 4.2.4 (x86_64-linux-gnu), the following file gives a compile
+error:
 
    
+
+
    #include <vector>
+void foo() { std::vector<int*> v(500l, NULL); }
+
    
+
 
    
-I believe this to be an example of a more general lack of rigor around
-copy and assignment, although I haven't done the research to dig up all
-the instances.
+Is this supposed to work? 
 
    
+
 
    
-It's a problem because if you don't know what CopyConstructible means,
-you also don't know what it means to copy a pair of CopyConstructible
-types.  It doesn't prevent us from writing code, but it is a hole in our
-ability to understand the meaning of copy.
+The issue: if NULL happens to be defined as 0l, this is an invocation of
+the constructor with two arguments of the same integral type.
+23.2.3 [sequence.reqmts]/11 says that this will behave as if the the
+overloaded constructor
 
    
+
+
    X(size_type, const value_type& = value_type(),
+  const allocator_type& = allocator_type())
+
    
+
 
    
-Furthermore, I'm pretty sure that vector's copy constructor doesn't
-require the elements to be EqualityComparable, so that table is actually
-referring to some ill-defined notion of equivalence when it uses ==.
+were called instead, with the arguments
+static_cast<size_type>(first), last and
+alloc, respectively. However, it does not say whether this
+actually means invoking that constructor with the exact textual form of
+the arguments as supplied by the user, or whether the standard permits
+an implementation to invoke that constructor with variables of the same
+type and value as what the user passed in. In most cases this is a
+distinction without a difference. In this particular case it does make a
+difference, since one of those things is a null pointer constant and the
+other is not.
+
    
+
+
    
+Note that an implementation based on forwarding functions will use the
+latter interpretation.
 
    
 
 
@@ -30882,1197 +26680,1592 @@ referring to some ill-defined notion of equivalence when it uses ==.
 
 
 
    
-
    1174. 	type property predicates
    
-
    Section: 20.6.4.3 [meta.unary.prop] Status: New
- Submitter: Jason Merrill Opened: 2009-07-16  Last modified: 2009-07-17
    
-
    View other active issues in [meta.unary.prop].
    
-
    View all other issues in [meta.unary.prop].
    
-
    View all issues with New status.
    
+
    1237. Constrained error_code/error_condition members
    
+
    Section: 19.5 [syserr] Status: Ready
+ Submitter: Daniel Krügler Opened: 2009-10-14  Last modified: 2009-10-26
    
+
    View all other issues in [syserr].
    
+
    View all issues with Ready status.
    
 
    Discussion:
    
 
    
-I've been implementing compiler support for is_standard_layout, and
-noticed a few nits about 20.6.4.3 [meta.unary.prop]:
+I'm just reflecting on the now SFINAE-constrained constructors
+and assignment operators of error_code and error_condition:
+
    
+
    
+These are the only library components that are pro-actively
+announcing that they are using std::enable_if as constraining tool,
+which has IMO several disadvantages:
 
    
 
 
      
 
    1. 
-There's no trait for "trivially copyable type", which is now the
-property that lets you do bitwise copying of a type, and therefore seems
-useful to be able to query.  has_trivial_assign &&
-has_trivial_copy_constructor && has_trivial_destructor
-is similar, but
-not identical, specifically with respect to const types.
+
      
+With the availability of template default arguments and
+decltype, using enable_if in C++0x standard library, seems
+unnecessary restricting implementation freedom. E.g. there
+should be not need for a useless specification of a dummy
+default function argument, which only confuses the reader.
+A more reasonable implementation could e.g. be
+
      
+
+
      template <class ErrorCodeEnum
+ class = typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type>
+error_code(ErrorCodeEnum e);
+
      
+
+
      
+As currently specified, the function signatures are so unreadable,
+that errors quite easily happen, see e.g. 1229.
+
      
+
      2. 
+
+
    2. 
+
      
+We have a lot of constrained functions in other places, that
+now have a standard phrase that is easily understandable:
+
      
+
+
      
+Remarks: This constructor/function shall participate in overload
+resolution if and only if X.
+
      
+
+
      
+where X describes the condition. Why should these components deviate?
+
      
 
      3. 
+
 
    3. 
-has_trivial_copy_constructor and has_trivial_assign lack the "or an
-array of such a class type" language that most other traits in that
-section, including has_nothrow_copy_constructor and has_nothrow_assign,
-have; this seems like an oversight.
+
      
+If enable_if would not be explicitly specified, the standard library
+is much better prepared for the future. It would also be possible, that
+libraries with partial support for not-yet-standard-concepts could provide
+a much better diagnostic as is possible with enable_if. This again
+would allow for experimental concept implementations in the wild,
+which as a result would make concept standardization a much more
+natural thing, similar to the way as templates were standardized
+in C++.
+
      
+
+
      
+In summary: I consider it as a library defect that error_code and
+error_condition explicitly require a dependency to enable_if and
+do limit implementation freedom and I volunteer to prepare a
+corresponding resolution.
+
      
 
      4. 
 
    
 
 
    [
-See the thread starting with c++std-lib-24420 for further discussion.
+2009-10-18 Beman adds:
 ]
    
 
 
+
    
+I support this proposed resolution, and thank Daniel for writing it up.
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Moved to Ready.
+
    
+
 
 
 
    Proposed resolution:
    
-
    
-
    
+
    [
+Should this resolution be accepted, I recommend to resolve 1229 as NAD
+]
    
 
 
+
      
+
    1. 
+
      
+In 19.5.2.1 [syserr.errcode.overview]/1, class error_code,
+change as indicated:
+
      
 
+
      // 19.5.2.2 constructors:
+error_code();
+error_code(int val, const error_category& cat);
+template <class ErrorCodeEnum>
+  error_code(ErrorCodeEnum e,
+    typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0);
 
+// 19.5.2.3 modifiers:
+void assign(int val, const error_category& cat);
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::typeerror_code&
+    operator=(ErrorCodeEnum e);
+void clear();
+
      
+
      2. 
 
-
      
-
      1175. unordered complexity
      
-
      Section: 23.2.5 [unord.req] Status: New
- Submitter: Pablo Halpern Opened: 2009-07-17  Last modified: 2009-07-19
      
-
      View other active issues in [unord.req].
      
-
      View all other issues in [unord.req].
      
-
      View all issues with New status.
      
-
      Discussion:
      
+
    2. 
 
      
-When I look at the unordered_* constructors, I think the complexity is poorly
-described and does not follow the style of the rest of the standard.
+Change 19.5.2.2 [syserr.errcode.constructors] around the prototype before p. 7:
 
      
 
+
      template <class ErrorCodeEnum>
+error_code(ErrorCodeEnum e,
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type * = 0);
+
      
+
      
 
      
-The complexity for the default constructor is specified as constant.
- Actually, it is proportional to n, but there are no invocations of
-value_type constructors or other value_type operations.
+Remarks: This constructor shall not participate in overload
+resolution, unless
+is_error_code_enum<ErrorCodeEnum>::value == true.
 
      
+
      
+
      
+
      3. 
 
+
    3. 
 
      
-For the iterator-based constructor the complexity should be:
+Change 19.5.2.3 [syserr.errcode.modifiers] around the prototype before p. 3:
 
      
 
+
      template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::typeerror_code&
+    operator=(ErrorCodeEnum e);
+
      
+
 
      
-Complexity: exactly n calls to construct value_type
-from InputIterator::value_type (where n = distance(f,l)).
-The number of calls to key_equal::operator() is proportional to
-n in the average case and n*n in the worst case.
+Remarks: This operator shall not participate in overload resolution, unless
+is_error_code_enum<ErrorCodeEnum>::value == true.
 
      
+
      
+
      4. 
 
-
-
-
      Proposed resolution:
      
+
    4. 
 
      
+In 19.5.3.1 [syserr.errcondition.overview]/1, class error_condition, change
+as indicated:
 
      
 
+
      // 19.5.3.2 constructors:
+error_condition();
+error_condition(int val, const error_category& cat);
+template <class ErrorConditionEnum>
+  error_condition(ErrorConditionEnum e,
+    typename enable_if<is_error_condition_enum<ErrorConditionEnum>::type* = 0);
 
+// 19.5.3.3 modifiers:
+void assign(int val, const error_category& cat);
+template<typenameclass ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::typeerror_condition &
+    operator=( ErrorConditionEnum e );
+void clear();
+
      
+
      5. 
 
+
    5. 
+
      
+Change 19.5.3.2 [syserr.errcondition.constructors] around the
+prototype before p. 7:
+
      
 
+
      template <class ErrorConditionEnum>
+  error_condition(ErrorConditionEnum e,
+    typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type* = 0);
+
      
+
      
+Remarks: This constructor shall not participate in overload
+resolution, unless
+is_error_condition_enum<ErrorConditionEnum>::value == true.
+
      
+
      
+
      6. 
 
-
      
-
      1176. Make thread constructor non-variadic
      
-
      Section: 30.3.1.2 [thread.thread.constr] Status: New
- Submitter: Howard Hinnant Opened: 2009-07-18  Last modified: 2009-07-18
      
-
      View other active issues in [thread.thread.constr].
      
-
      View all other issues in [thread.thread.constr].
      
-
      View all issues with New status.
      
-
      Discussion:
      
+
    6. 
 
      
-The variadic thread constructor is causing controversy, e.g.
-N2901.
-This issue has been created as a placeholder for this course of action.
+Change 19.5.3.3 [syserr.errcondition.modifiers] around the
+prototype before p. 3:
 
      
 
-
      template <class F, class ...Args> thread(F&& f, Args&&... args);
-
      
+
      template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::typeerror_condition&
+    operator=(ErrorConditionEnum e);
+
      
 
+
      
 
      
-See 929 for wording which specifies an rvalue-ref signature but
-with "decay behavior", but using variadics.
+Remarks: This operator shall not participate in overload resolution, unless
+is_error_condition_enum<ErrorConditionEnum>::value == true.
 
      
 
+
      
+Postcondition: *this == make_error_condition(e).
+
      
 
-
      Proposed resolution:
      
 
      
+Returns: *this
 
      
+
      
+
      
+
+
      7. 
+
    
+
 
 
 
 
 
 
    
-
    1177. Improve "diagnostic required" wording
    
-
    Section: 20.9.3 [time.duration] Status: New
- Submitter: Howard Hinnant Opened: 2009-07-18  Last modified: 2009-08-01
    
-
    View other active issues in [time.duration].
    
-
    View all other issues in [time.duration].
    
-
    View all issues with New status.
    
+
    1238. defining algorithms taking iterator for range
    
+
    Section: 25 [algorithms] Status: Tentatively NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-10-15  Last modified: 2009-11-03
    
+
    View other active issues in [algorithms].
    
+
    View all other issues in [algorithms].
    
+
    View all issues with Tentatively NAD Future status.
    
 
    Discussion:
    
 
    
-"diagnostic required" has been used (by me) for code words meaning "use
-enable_if to constrain templated functions.  This needs to be
-improved by referring to the function signature as not participating in
-the overload set, and moving this wording to a Remarks paragraph.
+The library has many algorithms that take a source range represented by
+a pair of iterators, and the start of some second sequence given by a
+single iterator.  Internally, these algorithms will produce undefined
+behaviour if the second 'range' is not as large as the input range, but
+none of the algorithms spell this out in Requires clauses, and there is
+no catch-all wording to cover this in clause 17 or the front matter of
+25.
 
    
 
-
-
-
    Proposed resolution:
    
-
    [
-This proposed resolution addresses 947 and 974. 
-]
    
-
-
 
    
-Change 20.9.3.1 [time.duration.cons]:
+There was an attempt to provide such wording in paper
+n2944
+but this
+seems incidental to the focus of the paper, and getting the wording of
+this issue right seems substantially more difficult than the simple
+approach taken in that paper.  Such wording will be removed from an
+updated paper, and hopefully tracked via the LWG issues list instead.
 
    
 
-
    
-
    template <class Rep2> 
-  explicit duration(const Rep2& r);
-
    
-
    
-
    
-Requires: Remarks:
-Rep2 shall be implicitly convertible to rep and
-
    
-
      
-
    • 
-treat_as_floating_point<rep>::value shall be true or
-
      • 
-
    • 
-treat_as_floating_point<Rep2>::value shall be false.
-
      • 
-
    
 
    
-Diagnostic required If these constraints are not met, this
-constructor shall not participate in overload resolution. [Example:
+It seems there are several classes of problems here and finding wording
+to solve all in one paragraph could be too much.  I suspect we need
+several overlapping requirements that should cover the desired range of
+behaviours.
 
    
-
    duration<int, milli> d(3); // OK 
-duration<int, milli> d(3.5); // error 
-
    
 
 
    
-— end example]
+Motivating examples:
 
    
 
 
    
-Effects: Constructs an object of type duration.
+A good initial example is the swap_ranges algorithm.  Here there is a
+clear requirement that first2 refers to the start of a valid range at
+least as long as the range [first1, last1).  n2944 tries to solve this
+by positing a hypothetical last2 iterator that is implied by the
+signature, and requires distance(first2,last2) < distance(first1,last1).
+ This mostly works, although I am uncomfortable assuming that last2 is
+clearly defined and well known without any description of how to obtain
+it (and I have no idea how to write that).
 
    
 
 
    
-Postcondition: count() == static_cast<rep>(r).
+A second motivating example might be the copy algorithm.  Specifically,
+let us image a call like:
 
    
 
-
    
+
    copy(istream_iterator<int>(is),istream_iterator(),ostream_iterator<int>(os));
+
    
 
-
    template <class Rep2, class Period2>
-  duration(const duration<Rep2, Period2>& d);
-
    
-
    
 
    
-Requires: Remarks: treat_as_floating_point<rep>::value shall be true or
-ratio_divide<Period2, period>::type::den shall be 1. Diagnostic
-required, else this constructor shall not participate in overload
-resolution. [Note: This requirement prevents implicit truncation error
-when converting between integral-based duration types. Such a
-construction could easily lead to confusion about the value of the
-duration. — end note] [Example:
+In this case, our input iterators are literally simple InputIterators,
+and the destination is a simple OutputIterator.  In neither case am I
+happy referring to std::distance, in fact it is not possible for the
+ostream_iterator at all as it does not meet the requirements.  However,
+any wording we provide must cover both cases.  Perhaps we might deduce
+last2 == ostream_iterator<int>{}, but that might not always be valid for
+user-defined iterator types.  I can well imagine an 'infinite range'
+that writes to /dev/null and has no meaningful last2.
 
    
 
-
    duration<int, milli> ms(3); 
-duration<int, micro> us = ms; // OK 
-duration<int, milli> ms2 = us; // error 
-
    
+
    
+The motivating example in n2944 is std::equal, and that seems to fall somewhere between the
+two.
+
    
 
 
    
-— end example]
+Outlying examples might be partition_copy that takes two output
+iterators, and the _n algorithms where a range is specified by a
+specific number of iterations, rather than traditional iterator pair. 
+We should also not accidentally apply inappropriate constraints to
+std::rotate which takes a third iterator that is not intended to be a
+separate range at all.
 
    
 
 
    
-Eff�ects: Constructs an object of type duration, constructing
-rep_ from
-duration_cast<duration>(d).count().
+I suspect we want some wording similar to:
 
    
 
+
    
+For algorithms that operate on ranges where the end iterator of the
+second range is not specified, the second range shall contain at least
+as many elements as the first.
 
    
 
-
-
    
+
    
+I don't think this quite captures the intent yet though.  I am not sure
+if 'range' is the right term here rather than sequence.  More awkwardly,
+I am not convinced we can describe an Output sequence such as produce by
+an ostream_iterator as "containing elements", at least not as a
+precondition to the call before they have been written.
+
    
 
 
    
-Change the following paragraphs in 20.9.3.5 [time.duration.nonmember]:
+Another idea was to describe require that the trailing iterator support
+at least distance(input range) applications of operator++ and may be
+written through the same number of times if a mutable/output iterator.
 
    
 
-
    
-
    template <class Rep1, class Period, class Rep2> 
-  duration<typename common_type<Rep1, Rep2>::type, Period> 
-  operator*(const duration<Rep1, Period>& d, const Rep2& s);
-
    
-
    
-Requires Remarks: Rep2 shall be implicitly convertible to
-CR(Rep1, Rep2), else this signature shall not participate in
-overload resolution. Diagnostic required.
-
    
+
    
+We might also consider handling the case of an output range vs. an input
+range in separate paragraphs, if that simplifies how we describe some of
+these constraints.
+
    
 
-
    template <class Rep1, class Period, class Rep2> 
-  duration<typename common_type<Rep1, Rep2>::type, Period> 
-  operator*(const Rep1& s, const duration<Rep2, Period>& d);
-
    
-
    
-Requires Remarks: Rep1 shall be implicitly convertible to
-CR(Rep1, Rep2), else this signature shall not participate in
-overload resolution. Diagnostic required.
-
    
+
    [
+2009-11-03 Howard adds:
+]
    
 
-
    template <class Rep1, class Period, class Rep2> 
-  duration<typename common_type<Rep1, Rep2>::type, Period> 
-  operator/(const duration<Rep1, Period>& d, const Rep2& s);
-
    
-
    
-Requires Remarks: Rep2 shall be implicitly convertible to
-CR(Rep1, Rep2) and Rep2 shall not be an instantiation of
-duration, else this signature shall not participate in
-overload resolution. Diagnostic required.
-
    
 
-
    template <class Rep1, class Period, class Rep2> 
-  duration<typename common_type<Rep1, Rep2>::type, Period> 
-  operator%(const duration<Rep1, Period>& d, const Rep2& s);
-
    
 
    
-Requires Remarks: Rep2 shall be implicitly convertible to
-CR(Rep1, Rep2) and Rep2 shall not be an instantiation of
-duration, else this signature shall not participate in
-overload resolution. Diagnostic required.
+Moved to Tentatively NAD Future after 5 positive votes on c++std-lib.
 
    
 
-
    
 
+
    Proposed resolution:
    
 
 
 
 
 
 
    
-
    1178. Header dependencies
    
-
    Section: 17.6.4.2 [res.on.headers] Status: Ready
- Submitter: Beman Dawes Opened: 2009-07-18  Last modified: 2009-07-18
    
-
    View all issues with Ready status.
    
+
    1239. Defect report
    
+
    Section: 20.6.4.3 [meta.unary.prop] Status: Tentatively NAD Editorial
+ Submitter: David Abrahams Opened: 2009-10-16  Last modified: 2009-10-26
    
+
    View other active issues in [meta.unary.prop].
    
+
    View all other issues in [meta.unary.prop].
    
+
    View all issues with Tentatively NAD Editorial status.
    
 
    Discussion:
    
 
    
-See Frankfurt notes of 1001.
+Table 43 defines a number of traits that yield true for arrays of class
+types with the trait's property, but not arrays of other types with that
+property.  For example, has_trivial_default_constructor:
 
    
 
+
    
+T is a trivial type (3.9) or a class type with a trivial default
+constructor (12.1) or an array of such a class type.
+
    
+
+
    [
+2009-10 post-Santa Cruz:
+]
    
 
-
    Proposed resolution:
    
-
    Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:
    
 
 
    
+
    
+An array of a trivial type is a trivial type.
+
    
+
    
+Mark as Tentatively NAD Editorial. The wording is OK as is,
+since an array of a trivial type is a trivial type, but the wording as
+proposed might be clearer.
+
    
+
    
+
+
 
+
    Proposed resolution:
    
 
    
-A C++ header may include other C++
-headers.[footnote] A C++ header shall provide
-the declarations and definitions that appear in its synopsis
-(3.2 [basic.def.odr]). A C++ header shown in its synopsis as including 
-other C++ headers shall provide the declarations and definitions that appear in
-the synopses of those other headers.
+Change all the traits in question following this pattern:
 
    
 
-  
    [footnote] C++ headers must include a C++ header that contains 
-  any needed definition (3.2).
    
+
    
+T is a trivial type (3.9) or a class type with a trivial default
+ constructor (12.1), or an array of such a class type.
 
    
 
+
    
+i.e., add a comma and delete a "class."
+
    
 
 
 
 
 
 
    
-
    1179. Probably editorial in [structure.specifications]
    
-
    Section: 17.5.1.4 [structure.specifications] Status: New
- Submitter: Robert Klarer Opened: 2009-07-21  Last modified: 2009-07-22
    
-
    View all other issues in [structure.specifications].
    
+
    1240. Deleted comparison functions of std::function not  needed
    
+
    Section: 20.7.15.2 [func.wrap.func] Status: New
+ Submitter: Daniel Krügler Opened: 2009-10-18  Last modified: 2009-10-19
    
+
    View all other issues in [func.wrap.func].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-While reviewing 971 I noted that 17.5.1.4 [structure.specifications]/7 says:
-
    
-
-
    
--7- Error conditions specify conditions where a function may fail. The
-conditions are listed, together with a suitable explanation, as the enum
-class errc constants (19.5) that could be used as an argument to
-function make_error_condition (19.5.3.6).
-
    
-
-
    
-This paragraph should mention make_error_code or the text "that
-could be used as an argument to function make_error_condition
-(19.5.3.6)" should be deleted.  I believe this is editorial.
+The class template std::function contains the following member
+declarations:
 
    
 
-
    [
-2009-07-21 Chris adds:
-]
    
-
+
    // deleted overloads close possible hole in the type system
+template<class R2, class... ArgTypes2>
+  bool operator==(const function<R2(ArgTypes2...)>&) = delete;
+template<class R2, class... ArgTypes2>
+  bool operator!=(const function<R2(ArgTypes2...)>&) = delete;
+
    
 
-
    
 
    
-I'm not convinced there's a problem there, because as far as the "Error
-conditions" clauses are concerned, make_error_condition() is used by a
-user to test for the condition, whereas make_error_code is not. For
-example:
+The leading comment here is part of the history of std::function, which
+was introduced with N1402.
+During that time no explicit conversion functions existed, and the
+"safe-bool" idiom (based on pointers-to-member) was a popular
+technique. The only disadvantage of this idiom was that given two
+objects f1 and f2 of type std::function the expression
 
    
 
-
    void foobar(error_code& ec = throws());
+
    f1 == f2;
 
    
 
 
    
- Error conditions:
+was well-formed, just because the built-in operator== for pointer to member
+was considered after a single user-defined conversion. To fix this, an
+overload set of undefined comparison functions was added,
+such that overload resolution would prefer those ending up in a linkage error.
+The new language facility of deleted functions provided a much better
+diagnostic mechanism to fix this issue.
 
    
-
    
-permission_denied - Insufficient privilege to perform operation.
-
    
 
 
    
-When a user writes:
+The central point of this issue is, that with the replacement of the
+safe-bool idiom by explicit conversion to bool the original "hole in the
+type system" does no longer exist and therefore the comment is wrong and
+the superfluous function definitions should be removed as well. An
+explicit conversion function is considered in direct-initialization
+situations only, which indirectly contain the so-called "contextual
+conversion to bool" (4 [conv]/3). These conversions are not considered for
+== or != as defined by the core language.
 
    
 
-
    error_code ec;
-foobar(ec);
-if (ec == errc::permission_denied)
-   ...
-
    
 
+
    Proposed resolution:
    
 
    
-the implicit conversion errc->error_condition makes the if-test
-equivalent to:
+In 20.7.15.2 [func.wrap.func]/1, class function change as indicated:
 
    
 
-
    if (ec == make_error_condition(errc::permission_denied))
+
    // 20.7.15.2.3, function capacity:
+explicit operator bool() const;
+
+// deleted overloads close possible hole in the type system
+template<class R2, class... ArgTypes2>
+  bool operator==(const function<R2(ArgTypes2...)>&) = delete;
+template<class R2, class... ArgTypes2>
+  bool operator!=(const function<R2(ArgTypes2...)>&) = delete;
 
    
 
+
+
+
+
+
    
+
    1241. unique_copy needs to require EquivalenceRelation
    
+
    Section: 25.3.9 [alg.unique] Status: Tentatively Ready
+ Submitter: Daniel Krügler Opened: 2009-10-17  Last modified: 2009-10-31
    
+
    View all other issues in [alg.unique].
    
+
    View all issues with Tentatively Ready status.
    
+
    Discussion:
    
 
    
-On the other hand, if the user had written:
+A lot of fixes were silently applied during concept-time and we should
+not lose them again. The Requires clause of 25.3.9 [alg.unique]/5
+doesn't mention that == and the predicate need to satisfy an
+EquivalenceRelation, as it is correctly said for
+unique. This was intentionally fixed during conceptification,
+were we had:
 
    
 
-
    if (ec == make_error_code(errc::permission_denied))
+
    template<InputIterator InIter, class OutIter>
+  requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
+        && EqualityComparable<InIter::value_type>
+        && HasAssign<InIter::value_type, InIter::reference>
+        && Constructible<InIter::value_type, InIter::reference>
+  OutIter unique_copy(InIter first, InIter last, OutIter result);
+
+template<InputIterator InIter, class OutIter,
+         EquivalenceRelation<auto, InIter::value_type> Pred>
+  requires OutputIterator<OutIter, RvalueOf<InIter::value_type>::type>
+        && HasAssign<InIter::value_type, InIter::reference>
+        && Constructible<InIter::value_type, InIter::reference>
+        && CopyConstructible<Pred>
+  OutIter unique_copy(InIter first, InIter last, OutIter result, Pred pred);
 
    
 
 
    
-the test is now checking for a specific error code. The test may
-evaluate to false even though foobar() failed due to the documented
-error condition "Insufficient privilege".
+Note that EqualityComparable implied an equivalence relation.
 
    
+
+
    [
+N.B. adjacent_find was also specified to require
+EquivalenceRelation, but that was considered as a defect in
+concepts, see 1000
+]
    
+
+
+
    [
+2009-10-31 Howard adds:
+]
    
+
+
+
    
+Moved to Tentatively Ready after 5 positive votes on c++std-lib.
 
    
 
 
+
 
    Proposed resolution:
    
 
    
+Change 25.3.9 [alg.unique]/5 as indicated:
 
    
 
+
    template<class InputIterator, class OutputIterator>
+  OutputIterator
+    unique_copy(InputIterator first, InputIterator last, OutputIterator result);
+
+template<class InputIterator, class OutputIterator, class BinaryPredicate>
+  OutputIterator
+    unique_copy(InputIterator first, InputIterator last,
+                OutputIterator result, BinaryPredicate pred);
+
    
+
    
+Requires: The comparison function shall be an equivalence
+relation. The ranges [first,last) and
+[result,result+(last-first)) shall not overlap. The expression
+*result = *first shall be valid. If neither
+InputIterator nor OutputIterator meets the
+requirements of forward iterator then the value type of
+InputIterator shall be CopyConstructible (34) and
+CopyAssignable (table 36). Otherwise CopyConstructible
+is not required.
+
    
+
    
+
 
 
 
 
 
    
-
    1180. Missing string_type member typedef in class sub_match
    
-
    Section: 28.9.1 [re.submatch.members] Status: New
- Submitter: Daniel Krügler Opened: 2009-07-25  Last modified: 2009-07-26
    
+
    1244. wait_*() in *future for synchronous functions
    
+
    Section: 30.6 [futures] Status: New
+ Submitter: Detlef Vollmann Opened: 2009-10-22  Last modified: 2009-10-23
    
+
    View all other issues in [futures].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-The definition of class template sub_match is strongly dependent
-on the type basic_string<value_type>, both in interface and effects,
-but does not provide a corresponding typedef string_type, as e.g.
-class match_results does, which looks like an oversight to me that
-should be fixed.
+With the addition of async(), a future might be
+associated with a function that is not running in a different thread but
+is stored to by run synchronously on the get() call. It's not
+clear what the wait() functions should do in this case.
 
    
 
+
    
+Suggested resolution:
+
    
 
-
    Proposed resolution:
    
-
-
      
-
    1. 
 
      
-In the class template sub_match synopsis 28.9 [re.submatch]/1
-change as indicated:
+Throw an exception.
 
      
 
-
      template <class BidirectionalIterator>
-class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator> {
-public:
-  typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
-  typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type;
-  typedef BidirectionalIterator iterator;
-  typedef basic_string<value_type> string_type;
 
-  bool matched;
+
      Proposed resolution:
      
 
-  difference_type length() const;
-  operator basic_string<value_type>string_type() const;
-  basic_string<value_type>string_type str() const;
-  int compare(const sub_match& s) const;
-  int compare(const basic_string<value_type>string_type& s) const;
-  int compare(const value_type* s) const;
-};
-
      
-
      2. 
 
-
    2. 
+
+
+
+
      
+
      1245. std::hash<string> & co
      
+
      Section: 20.7.16 [unord.hash] Status: New
+ Submitter: Paolo Carlini Opened: 2009-10-22  Last modified: 2009-10-25
      
+
      View other active issues in [unord.hash].
      
+
      View all other issues in [unord.hash].
      
+
      View all issues with New status.
      
+
      Discussion:
      
 
      
-In 28.9.1 [re.submatch.members]/2 change as indicated:
+In 20.7.16 [unord.hash], operator() is specified as
+taking the argument by value. Moreover, it is said that operator() shall
+not throw exceptions.
 
      
 
-
      operator basic_string<value_type>string_type() const;
-
      
+
      
+However, for the specializations for class types, like string, wstring,
+etc, the former requirement seems suboptimal from the performance point
+of view (a specific PR has been filed about this in the GCC Bugzilla)
+and, together with the latter requirement, hard if not impossible to
+fulfill. It looks like pass by const reference should be allowed in such
+cases.
+
      
 
-
      
-Returns: matched ? basic_string<value_type>
-string_type(first, second) : basic_string<value_type>
-string_type().
-
      
-
      
-
      3. 
 
-
    3. 
+
      Proposed resolution:
      
 
      
-In 28.9.1 [re.submatch.members]/3 change as indicated:
+Add to 20.7.16 [unord.hash]/2:
 
      
 
-
      basic_string<value_type>string_type str() const;
+
      
+
      namespace std {
+  template <class T>
+  struct hash : public std::unary_function<T, std::size_t> {
+    std::size_t operator()(T val) const;
+  };
+}
 
      
 
-
      
-Returns: matched ? basic_string<value_type>
-string_type(first, second) : basic_string<value_type>
-string_type().
-
      
+
      
+The return value of operator() is unspecified, except that
+equal arguments shall yield the same result. operator() shall
+not throw exceptions. It is also unspecified whether
+operator() of std::hash specializations for class
+types takes its argument by value or const reference.
+
      
 
      
-
      4. 
-
    
-
 
 
 
 
 
 
    
-
    1181. Invalid sub_match comparison operators
    
-
    Section: 28.9.2 [re.submatch.op] Status: New
- Submitter: Daniel Krügler Opened: 2009-07-25  Last modified: 2009-07-28
    
-
    View all other issues in [re.submatch.op].
    
+
    1246. vector::resize() missing efficiency guarantee
    
+
    Section: 23.3.6.2 [vector.capacity] Status: New
+ Submitter: David Abrahams Opened: 2009-10-24  Last modified: 2009-10-25
    
+
    View all other issues in [vector.capacity].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-Several heterogeneous comparison operators of class template
-sub_match are specified by return clauses that are not valid
-in general. E.g. 28.9.2 [re.submatch.op]/7:
+If v is a vector, I think repeated calls to
+v.resize( v.size() + 1 ) should be amortized O(1), but it's not
+clear that's true from the text of the standard:
 
    
 
-
    template <class BiIter, class ST, class SA>
-bool operator==(
-  const basic_string<
-    typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-  const sub_match<BiIter>& rhs);
+
    void resize(size_type sz);
 
    
 
    
-Returns: lhs == rhs.str().
+Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If
+size() < sz, appends sz - size() default constructed elements to the
+sequence.
 
    
 
    
 
 
    
-The returns clause would be ill-formed for all cases where
-ST != std::char_traits<iterator_traits<BiIter>::value_type>
-or SA != std::allocator<iterator_traits<BiIter>::value_type>.
-
    
-
    
-The generic character of the comparison was intended, so
-there are basically two approaches to fix the problem: The
-first one would define the semantics of the comparison
-using the traits class ST (The semantic of basic_string::compare
-is defined in terms of the compare function of the corresponding
-traits class), the second one would define the semantics of the
-comparison using the traits class
+Seems to me if we used push_back instead of appends, we might be giving
+the guarantee I'd like.  Thoughts?
 
    
 
-
    std::char_traits<iterator_traits<BiIter>::value_type>
-
    
 
+
    Proposed resolution:
    
 
    
-which is essentially identical to
+In 23.3.6.2 [vector.capacity]/10, change
 
    
 
-
    std::char_traits<sub_match<BiIter>::value_type>
-
    
+
    void resize(size_type sz);
+
    
+
    
+Effects: If sz < size(), equivalent to erase(begin() + sz, end());. If
+size() < sz, appends sz - size() default constructed elements to the
+sequence
+equivalent to sz - size() consecutive evaluations of push_back(T()).
+
    
+
    
 
-
    
-I suggest to follow the second approach, because
-this emphasizes the central role of the sub_match
-object as part of the comparison and would also
-make sure that a sub_match comparison using some
-basic_string<char_t, ..> always is equivalent to
-a corresponding comparison with a string literal
-because of the existence of further overloads (beginning
-from 28.9.2 [re.submatch.op]/19). If users really want to
-take advantage of their own traits::compare, they can
-simply write a corresponding compare function that
-does so.
-
    
 
 
-
    Proposed resolution:
    
-
      
-
    1. 
+
+
+
+
      
+
      1247. auto_ptr is overspecified
      
+
      Section: D.10.1 [auto.ptr] Status: Review
+ Submitter: Alisdair Meredith Opened: 2009-10-24  Last modified: 2009-11-06
      
+
      View all other issues in [auto.ptr].
      
+
      View all issues with Review status.
      
+
      Discussion:
      
 
      
-In 28.9.2 [re.submatch.op] change as indicated:
+This issue is extracted as the ongoing point-of-interest from earlier
+issue 463.
 
      
 
-
        
-
      1. 
+
        
+auto_ptr is overspecified as the auto_ptr_ref
+implementation detail is formally specified, and the technique is
+observable so workarounds for compiler defects can  cause a working
+implementation of the primary auto_ptr template become
+non-conforming.
+
        
 
 
        
-If 1180 is accepted:
+auto_ptr_ref is a documentation aid to describe a possible
+mechanism to implement the class.  It should be marked exposition only,
+as per similar classes, e.g., istreambuf_iterator::proxy
 
        
 
-
        
-
        template <class BiIter, class ST, class SA>
-  bool operator==(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
        
-
        
-7 Returns: lhstypename
-sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) ==
-rhs.str().
-
        
+
        [
+2009-10-25 Daniel adds:
+]
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator!=(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
        
 
 
        
-8 Returns: lhstypename
-sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) !=
-rhs.str().
-
        
-
-
        template <class BiIter, class ST, class SA>
-  bool operator<(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
        
+
        
+I wonder, whether the revised wording shouldn't be as straight as
+for istream_buf by adding one further sentence:
+
        
 
 
        
-9 Returns: lhstypename
-sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) <
-rhs.str().
+An implementation is permitted to provide equivalent functionality without
+providing a class with this name.
+
        
 
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator>(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
        
+
        [
+2009-11-06 Alisdair adds Daniel's suggestion to the proposed wording.
+]
        
 
-
        
-10 Returns: lhstypename
-sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) >
-rhs.str().
-
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator>=(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
        
+
        [
+2009-11-06 Howard moves issue to Review.
+]
        
 
-
        
-11 Returns: lhstypename
-sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) >=
-rhs.str().
-
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator<=(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
        
 
-
        
-12 Returns: lhstypename
-sub_match<BiIter>::string_type(lhs.begin(), lhs.end()) <=
-rhs.str().
-
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator==(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
        
+
        Proposed resolution:
        
+
        
+Add the term "exposition only" in the following two places:
+
        
+
+
        
+Ammend D.10.1 [auto.ptr]p2:
+
        
 
 
        
-13 Returns: lhs.str() == rhstypename
-sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
+
        
+The exposition only class  Ttemplate auto_ptr_ref
+holds a reference to an auto_ptr. It is used by the
+auto_ptr conversions to allow auto_ptr objects to be
+passed to and returned from functions.
+An implementation is permitted to provide equivalent functionality
+without providing a class with this name.
+
        
+
+
        namespace std {
+ template <class Y> struct auto_ptr_ref { }; // exposition only
+
        
 
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator!=(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
        
 
-
        
-14 Returns: lhs.str() != rhstypename
-sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
-
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator<(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
        
 
-
        
-15 Returns: lhs.str() < rhstypename
-sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
-
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator>(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
        
+
        
+
        1249. basic_ios default ctor
        
+
        Section: 27.5.4.1 [basic.ios.cons] Status: New
+ Submitter: Martin Sebor Opened: 2009-10-25  Last modified: 2009-10-26
        
+
        View all other issues in [basic.ios.cons].
        
+
        View all issues with New status.
        
+
        Discussion:
        
+
        
+The basic_ios default ctor is required to leave the objects members
+uninitialized (see below). The paragraph says the object must be
+initialized by calling basic_ios::init() before it's destroyed by
+I can't find a requirement that it be initialized before calling
+any of the class other member functions. Am I not looking in the
+right place or that an issue?
+
        
 
-
        
-16 Returns: lhs.str() > rhstypename
-sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
-
        
+
        [
+2009-10-25 Daniel adds:
+]
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator>=(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
        
 
 
        
-17 Returns: lhs.str() >= rhstypename
-sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
-
        
+
        
+I agree, that your wording makes that clearer, but suggest to write
+
        
 
-
        template <class BiIter, class ST, class SA>
-  bool operator<=(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
        
+
        
+... calling basic_ios::init() before ...
+
        
+
+
        
+Doing so, I recommend to adapt that of ios_base(); as well, where
+we have:
+
        
 
 
        
-18 Returns: lhs.str() <= rhstypename
-sub_match<BiIter>::string_type(rhs.begin(), rhs.end()).
+Effects: Each ios_base member has an indeterminate value
+after construction. These members shall be initialized by calling
+basic_ios::init. If an ios_base object is destroyed
+before these initializations have taken place, the behavior is
+undefined.
 
        
 
    
 
-
 
-
  • 
 
+
    Proposed resolution:
    
 
    
-If 1180 is not accepted:
+Change 27.5.2.7 [ios.base.cons] p1:
 
    
 
-
    
-
    template <class BiIter, class ST, class SA>
-  bool operator==(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
+
    ios_base();
 
    
 
    
-7 Returns: lhsbasic_string<typename
-sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) ==
-rhs.str().
+Effects: Each ios_base member has an indeterminate value
+after construction. These The object's members shall be initialized by calling
+basic_ios::init before the object's first use or before
+ it is destroyed, whichever comes first; otherwise the behavior
+ is undefined.. If an ios_base object is destroyed
+before these initializations have taken place, the behavior is
+undefined.
+
    
 
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator!=(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
    
+
    
+Change 27.5.4.1 [basic.ios.cons] p2:
+
    
 
+
    basic_ios();
+
    
 
    
-8 Returns: lhsbasic_string<typename
-sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) !=
-rhs.str().
+Effects: Constructs an object of class basic_ios
+(27.5.2.7) leaving its member objects uninitialized. The object shall be
+initialized by calling its
+basic_ios::init before its first
+use or before it is destroyed, whichever comes first; otherwise the
+behavior is undefined. member function. If it is destroyed
+before it has been initialized the behavior is undefined.
+
    
 
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator<(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
    
 
-
    
-9 Returns: lhsbasic_string<typename
-sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) <
-rhs.str().
-
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator>(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
    
 
-
    
-10 Returns: lhsbasic_string<typename
-sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) >
-rhs.str().
-
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator>=(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
    
+
    
+
    1250. <bitset> still overspecified
    
+
    Section: 20.3.7 [template.bitset] Status: New
+ Submitter: Martin Sebor Opened: 2009-10-29  Last modified: 2009-10-29
    
+
    View other active issues in [template.bitset].
    
+
    View all other issues in [template.bitset].
    
+
    View all issues with New status.
    
+
    Discussion:
    
+
    
+Issue 1227 — <bitset> synopsis overspecified makes the observation
+that std::bitset, and in fact the whole library, may be implemented
+without needing to #include <stdexcept> in any library header. The
+proposed resolution removes the #include <stdexcept> directive from
+the header.
+
    
 
-
    
-11 Returns: lhsbasic_string<typename
-sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) >=
-rhs.str().
-
    
+
    
+I'd like to add that the <bitset> header (as well as the rest of
+the library) has also been implemented without #including the
+<cstddef> header in any library header. In the case of std::bitset,
+the template is fully usable (i.e., it may be instantiated and all
+its member functions may be used) without ever mentioning size_t.
+In addition, just like no library header except for <bitset>
+#includes <stdexcept> in its synopsis, no header but <bitset>
+#includes <cstddef> either.
+
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator<=(
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
-    const sub_match<BiIter>& rhs);
-
    
+
    
+Thus I suggest that the #include <cstddef> directive be similarly
+removed from the synopsis of <bitset>.
+
    
 
-
    
-12 Returns: lhsbasic_string<typename
-sub_match<BiIter>::value_type>(lhs.begin(), lhs.end()) <=
-rhs.str().
-
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator==(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
    
+
    Proposed resolution:
    
+
    
+Change 20.3.7 [template.bitset]:
+
    
 
-
    
-13 Returns: lhs.str() == rhsbasic_string<typename
-sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
-
    
+
    #include <cstddef>        // for size_t
+#include <string>
+#include <iosfwd>         // for istream, ostream
+namespace std {
+...
+
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator!=(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
    
 
-
    
-14 Returns: lhs.str() != rhsbasic_string<typename
-sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
-
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator<(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
    
 
-
    
-15 Returns: lhs.str() < rhsbasic_string<typename
-sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
-
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator>(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
    
+
    
+
    1251. move constructing basic_stringbuf
    
+
    Section: 27.8.1.1 [stringbuf.cons] Status: New
+ Submitter: Martin Sebor Opened: 2009-10-29  Last modified: 2009-10-29
    
+
    View all other issues in [stringbuf.cons].
    
+
    View all issues with New status.
    
+
    Discussion:
    
+
    
+I just came across issue 1204 -- Global permission to move, which
+seems to address the concern raised by the example in c++std-lib-25030.
+
    
+
    
+IIUC, the example violates the permission to assume that arguments
+bound to rvalue references are unnamed temporaries granted to
+implementations by the resolution of issue 1204 - Global permission
+to move.
+
    
 
-
    
-16 Returns: lhs.str() > rhsbasic_string<typename
-sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
-
    
+
    
+I.e., the ostringstream(ostringstream &&rhs) ctor can leave the rhs
+pointers pointing to the newly constructed object's buffer just as
+long as the dtor doesn't change or invalidate the buffer. The caller
+may not make any assumptions about rhs after the move beyond it being
+safe to destroy or reassign.
+
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator>=(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
-
    
+
    
+So unless I misunderstood something, I still think the basic_stringbuf
+move ctor is overspecified. Specifically, I think the third sentence
+in the Effects clause and the last 6 bullets in the Postconditions
+clause can, and IMO should, be stricken.
+
    
+
+
+
    Proposed resolution:
    
+
    
+Strike from 27.8.1.1 [stringbuf.cons]:
+
    
 
+
    basic_stringbuf(basic_stringbuf&& rhs);
+
    
 
    
-17 Returns: lhs.str() >= rhsbasic_string<typename
-sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
+
    
+Effects: Move constructs from the rvalue rhs. It is
+implementation-defined whether the sequence pointers in *this
+(eback(), gptr(), egptr(), pbase(),
+pptr(), epptr()) obtain the values which rhs
+had. Whether they do or not, *this and rhs reference
+separate buffers (if any at all) after the construction. The openmode,
+locale and any other state of rhs is also copied.
+
    
+
+
    
+Postconditions: Let rhs_p refer to the state of
+rhs just prior to this construction and let rhs_a
+referto the state of rhs just after this construction.
+
    
+
      
+
    • 
+str() == rhs_p.str()
+
      • 
+
    • 
+gptr() - eback() == rhs_p.gptr() - rhs_p.eback()
+
      • 
+
    • 
+egptr() - eback() == rhs_p.egptr() - rhs_p.eback()
+
      • 
+
    • 
+pptr() - pbase() == rhs_p.pptr() - rhs_p.pbase()
+
      • 
+
    • 
+epptr() - pbase() == rhs_p.epptr() - rhs_p.pbase()
+
      • 
+
    • 
+if (eback()) eback() != rhs_a.eback()
+
      • 
+
    • 
+if (gptr()) gptr() != rhs_a.gptr()
+
      • 
+
    • 
+if (egptr()) egptr() != rhs_a.egptr()
+
      • 
+
    • 
+if (pbase()) pbase() != rhs_a.pbase()
+
      • 
+
    • 
+if (pptr()) pptr() != rhs_a.pptr()
+
      • 
+
    • 
+if (epptr()) epptr() != rhs_a.epptr()
+
      • 
+
    
+
    
 
    
 
-
    template <class BiIter, class ST, class SA>
-  bool operator<=(const sub_match<BiIter>& lhs,
-    const basic_string<
-      typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
+
+
+
+
+
+
    
+
    1252. wbuffer_convert::state_type inconsistency
    
+
    Section: 22.3.3.2.3 [conversions.buffer] Status: New
+ Submitter: Bo Persson  Opened: 2009-10-21  Last modified: 2009-10-31
    
+
    View all issues with New status.
    
+
    Discussion:
    
+
    
+The synopisis for wbuffer_convert 22.3.3.2.3 [conversions.buffer]/2 contains
+
    
+
+
    typedef typename Tr::state_type   state_type; 
+
    
+
+
    
+making state_type a synonym for (possibly) some
+char_traits<x>::state_type. 
+
    
+
+
    
+However, in paragraph 9 of the same section, we have 
+
    
+
+
    typedef typename Codecvt::state_type state_type;
 
    
 
 
    
-18 Returns: lhs.str() <= rhsbasic_string<typename
-sub_match<BiIter>::value_type>(rhs.begin(), rhs.end()).
+The type shall be a synonym for Codecvt::state_type.
 
    
 
    
 
-
    • 
+
    
+From what I can see, it might be hard to implement
+wbuffer_convert if the types were not both
+std::mbstate_t, but I cannot find a requirement that they must
+be the same type.
+
    
 
-
 
-
-
+
    Proposed resolution:
    
 
 
 
 
 
 
    
-
    1182. Unfortunate hash dependencies
    
-
    Section: 20.7.17 [unord.hash] Status: New
- Submitter: Alisdair Meredith Opened: 2009-07-28  Last modified: 2009-07-30
    
-
    View other active issues in [unord.hash].
    
-
    View all other issues in [unord.hash].
    
+
    1253. invalidation of iterators and emplace vs. insert inconsistence in assoc. containers
    
+
    Section: 23.2.4 [associative.reqmts] Status: New
+ Submitter: Boris Dušek Opened: 2009-10-24  Last modified: 2009-10-31
    
+
    View other active issues in [associative.reqmts].
    
+
    View all other issues in [associative.reqmts].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-The implied library dependencies created by spelling out all the hash
-template specializations in the <functional> synopsis are unfortunate. 
-The potential coupling is greatly reduced if the hash specialization is
-declared in the appropriate header for each library type, as it is much
-simpler to forward declare the primary template and provide a single
-specialization than it is to implement a hash function for a string or
-vector without providing a definition for the whole string/vector
-template in order to access the necessary bits.
+In the latest published draft
+N2960,
+section 23.2.4 [associative.reqmts], paragraph 8, it is specifies
+that that insert does not invalidate any iterators. As per
+23.2.1 [container.requirements.general], paragraph 12, this holds
+true not only for insert, but emplace as well. This
+gives the insert member a special treatment w.r.t.
+emplace member in 23.2.4 [associative.reqmts], par. 8,
+since both modify the container. For the sake of consistency, in 23.2.4 [associative.reqmts], par. 8: either reference to
+insert should be removed (i.e. count on 23.2.1 [container.requirements.general], par. 12), or reference to
+emplace be added (i.e. mention all members of assoc. containers
+that modify it).
 
    
 
+
+
    Proposed resolution:
    
 
    
-Note that the proposed resolution purely involves moving the
-declarations of a few specializations, it specifically does not make any
-changes to 20.7.17 [unord.hash].
 
    
 
 
-
    Proposed resolution:
    
+
+
+
+
    
+
    1254. Misleading sentence in vector<bool>::flip
    
+
    Section: 23.3.7 [vector.bool] Status: New
+ Submitter: Christopher Jefferson Opened: 2009-11-01  Last modified: 2009-11-01
    
+
    View all other issues in [vector.bool].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Strike the following specializations declared in the <functional>
-synopsis p2 20.7 [function.objects]
+The effects of vector<bool>::flip has the line:
 
    
 
-
    template <> struct hash<std::string>;
-template <> struct hash<std::u16string>;
-template <> struct hash<std::u32string>;
-template <> struct hash<std::wstring>;
+
    
+It is unspecified whether the function has any effect on allocated but
+unused bits.
+
    
 
-template <class Allocator> struct hash<std::vector<bool, Allocator> >;
-template <std::size_t N> struct hash<std::bitset<N> >;
-
    
+
    
+While this is technically true, it is misleading, as any member function
+in any standard container may change unused but allocated memory. Users
+can never observe such changes as it would also be undefined behaviour
+to read such memory.
+
    
 
+
+
    Proposed resolution:
    
 
    
-Add the following declarations to the synopsis of <string> in
-21.3 [string.classes]
+Strike second sentence from the definition of vector<bool>::flip(),
+23.3.7 [vector.bool], paragraph 5.
 
    
 
-
    // 21.4.x hash support
-template <class T> struct hash;
-template <> struct hash<string>;
-template <> struct hash<u16string>;
-template <> struct hash<u32string>;
-template <> struct hash<wstring>;
-
    
+
    
+Effects: Replaces each element in the container with its complement.
+It is unspecified whether the function has any effect on allocated
+but unused bits.
+
    
+
+
+
 
+
+
    
+
    1255. declval should be added to the library
    
+
    Section: 20.3 [utility] Status: New
+ Submitter: Daniel Krügler Opened: 2009-11-03  Last modified: 2009-11-04
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Add a new clause 21.4.X
+During the Santa Cruz meeting it was decided to split off the provision
+of the library utility value() proposed in N2979
+from the concrete request of the
+UK 300
+comment.
+The provision of a new library component that allows the production of
+values in unevaluated expressions is considered as important
+to realize constrained templates in C++0x where concepts are not
+available.
 
    
 
-
    
 
    
-21.4.X Hash support [basic.string.hash]
+The following proposed resolution is an improvement over that suggested in
+N2958,
+because the proposed component can now be defined without loss of
+general usefulness and any use by user-code will make the program ill-formed.
+A possible prototype implementation that satisfies the core language
+requirements
+can be written as:
 
    
 
-
    template <> struct hash<string>;
-template <> struct hash<u16string>;
-template <> struct hash<u32string>;
-template <> struct hash<wstring>;
-
    
+
    template<class T>
+  struct declval_protector {
+    static const bool stop = false;
+    static typename std::add_rvalue_reference<T>::type delegate(); // undefined
+  };
 
-
    
-Explicit specializations of the class template hash (20.7.17 [unord.hash])
-shall be provided for the types string, u16string,
-u32string and wstring suitable for using these types as keys in
-unordered associative containers (23.5 [unord]).
-
    
-
    
+template<class T>
+typename std::add_rvalue_reference<T>::type declval() {
+  static_assert(declval_protector<T>::stop, "declval() must not be used!");
+  return declval_protector<T>::delegate();
+}
+
    
 
 
    
-Add the following declarations to the synopsis of <vector> in 
-23.3 [sequences]
+Further-on the earlier suggested name value() has been changed to declval()
+after discussions with committee members.
 
    
 
-
    
-// 21.4.x hash support
-template <class T> struct hash;
-template <class Allocator> struct hash<vector<bool, Allocator>>;
-
    
-
 
    
-Add a new paragraph to the end of 23.3.7 [vector.bool]
+Finally the suggestion shown below demonstrates that it can simplify
+existing standard wording by directly using it in the library
+specification, and that it also improves an overlooked corner case for
+common_type by adding support for cv void.
 
    
 
-
    template <class Allocator> struct hash<vector<bool, Allocator>>;
-
    
-
    
-A partial specialization of the class template hash (20.7.17 [unord.hash])
-shall be provided for vectors of boolean values suitable for use as a key
-in unordered associative containers (23.5 [unord]).
-
    
-
    
 
+
    Proposed resolution:
    
+
    [
+The following edit assumes that the earlier component identity
+has been removed as part of applying the solution of 939,
+N2951,
+and
+N2984.
+Note that the proposal does not depend on this application,
+but it just simplifies the editorial representation
+]
    
+
+
+
      
+
    1. 
 
      
-Add the following declarations to the synopsis of <bitset>
-in 20.3.6 [template.bitset]
+Change 20.3 [utility], header <utility> synopsis
+as indicated:
 
      
 
-
      
-// 20.3.6.X hash support
-template <class T> struct hash;
-template <size_t N> struct hash<bitset<N> >;
-
      
+
      // 20.3.2, forward/move:
+template <class T, class U> T&& forward(U&& u);;
+template <class T> typename remove_reference<T>::type&& move(T&&);
+
+// 20.3.3, declval:
+template <class T> typename add_rvalue_reference<T>::type declval(); // for unused context
+
      
+
      2. 
 
+
    2. 
 
      
-Add a new subclause 20.3.6.X [bitset.hash]
+Immediately after the current section 20.3.3 [forward] insert a
+new section:
 
      
-
-
      
 
      
-20.3.6.X bitset hash support [bitset.hash]
+20.3.3 Function template declval [declval]
+
      
+
      
+The library provides the function template declval to simplify
+the definition of expressions in
+unevaluated and unused contexts (3.2 [basic.def.odr], 5 [expr]). The
+template parameter T of declval may
+be an incomplete type.
 
      
 
-
      template <size_t N> struct hash<bitset<N> >;
+
      template <class T> typename add_rvalue_reference<T>::type declval(); // for unused context
 
      
 
 
      
-A partial specialization of the class template hash
-(20.7.17 [unord.hash]) shall be provided for bitsets suitable for use as a key in
-unordered associative containers (23.5 [unord]).
-
      
-
      
+
      
+Remarks: If this function is used according to 3.2 [basic.def.odr],
+the program shall be ill-formed.
+
      
 
+
      
+[Example:
+
      
 
+
      
+template<class To, class From>
+decltype(static_cast<To>(declval<From>())) convert(From&&);
+
      
 
+
      
+
+declares a function template convert, which does only participate in
+overloading, if the type From can be
+explicitly casted to type To — end example]
+
      
+
    
 
+
 
+
  • 
+
    
+This bullet just makes clear that after applying N2984, the changes in 20.6.4.3 [meta.unary.prop], before
+table Type property queries should not use declval,
+because the well-formedness requirement of the specification of
+is_constructible would become more complicated, because we
+would need to make sure that the expression CE is checked in an
+unevaluated context.
+
    
+
    • 
 
-
    
-
    1183. basic_ios::set_rdbuf may break class invariants
    
-
    Section: 27.5.4.2 [basic.ios.members] Status: New
- Submitter: Daniel Krügler Opened: 2009-07-28  Last modified: 2009-07-28
    
-
    View other active issues in [basic.ios.members].
    
-
    View all other issues in [basic.ios.members].
    
-
    View all issues with New status.
    
-
    Discussion:
    
+
  • 
 
    
-The protected member function set_rdbuf had been added during the
-process of adding move and swap semantics to IO classes. A relevant
-property of this function is described by it's effects in
-27.5.4.2 [basic.ios.members]/19:
+Also 20.6.5 [meta.rel]/4 is not modified similar to the previous bullet,
+because with
+the stricter requirements of not using declval() the well-formedness condition
+would be harder to specify. The following changes are only editorial ones (e.g.
+the removal of the duplicate declaration of create()):
 
    
 
 
    
-Effects: Associates the basic_streambuf object pointed to by sb with
-this stream without calling clear().
-
    
-
 
    
-This means that implementors of or those who derive from existing IO classes
-could cause an internal state where the stream buffer could be 0, but the
-IO class has the state good(). This would break several currently existing
-implementations which rely on the fact that setting a stream buffer via the
-currently only ways, i.e. either by calling
+Given the following function prototype:
 
    
 
-
    void init(basic_streambuf<charT,traits>* sb);
+
    template <class T>
+  typename add_rvalue_reference<T>::type create();
 
    
 
 
    
-or by calling
+the predicate condition for a template specialization
+is_convertible<From, To> shall be satisfied if and only
+if the return expression in the following code would be well-formed,
+including any
+immplicit conversions to the return type of the function:
 
    
 
-
    basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);
+
    template <class T>
+typename add_rvalue_reference<T>::type create();
+To test() {
+  return create<From>();
+}
 
    
+
    
+
    • 
 
+
  • 
 
    
-to set rdstate() to badbit, if the buffer is 0. This has the effect that many
-internal functions can simply check rdstate() instead of rdbuf() for being 0.
+Change the entry in column "Comments" for common_type in Table 51 —
+Other transformations (20.6.7 [meta.trans.other]):
 
    
 
-
    
-I therefore suggest that a requirement is added for callers of set_rdbuf to
-set a non-0 value.
-
    
+
    [
+NB: This wording change extends the type domain of common_type for cv
+void => cv void transformations and thus makes common_type usable for
+all binary type combinations that are supported by is_convertible
+]
    
 
 
-
    Proposed resolution:
    
+
    
+The member typedef type shall be defined as set out below. All
+types in the parameter pack T shall be complete or
+(possibly cv-qualified) void. A program may specialize
+this trait if at least one template parameter in the specialization is a
+user-defined type. [Note: Such specializations are needed when
+only explicit conversions are desired among the template arguments.
+— end note]
+
    
+
    • 
+
+
  • 
 
    
-Change 27.5.4.2 [basic.ios.members] around p. 19 as indicated (The proposed
-resolution fixes also two editorial problems: Some wrong letters in "clear()"
-and moving the post conditions into a separate paragraph):
+Change 20.6.7 [meta.trans.other]/3 as indicated:
 
    
 
-
    void set_rdbuf(basic_streambuf<charT, traits>* sb);
-
    
+
    [
+NB: This wording change is more than an editorial simplification of
+the definition of common_type: It also extends its usefulness for cv
+void types as outlined above
+]
    
+
 
 
    
 
    
-Requires: sb != nullptr.
+The nested typedef common_type::type shall be defined as follows:
 
    
 
+
    
 
    
-Effects: Associates the basic_streambuf object pointed to by sb with
-this stream without
-calling clear(). Postconditions: rdbuf() == sb.
+[..]
 
    
+
    template <class T, class U>
+struct common_type<T, U> {
+private:
+  static T&& __t();
+  static U&& __u();
+public:
+  typedef decltype(true ? __tdeclval<T>() : __udeclval<U>()) type;
+};
+
    
+
    
+
    
+
    • 
+
+
+
 
+
+
+
+
    
+
    1256. weak_ptr comparison functions should be removed
    
+
    Section: 20.8.15.3 [util.smartptr.weak] Status: New
+ Submitter: Daniel Krügler Opened: 2009-11-04  Last modified: 2009-11-04
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-Postconditions: rdbuf() == sb.
+Additional to the necessary cleanup of the description of the the
+weak_ptr component from 20.8.15.3 [util.smartptr.weak]
+described in 1231 it turns out that the currently deleted
+comparison functions of weak_ptr are not needed at all: There
+is no safe-bool conversion from weak_ptr, and it won't silently
+chose a conversion to shared_ptr.
 
    
 
+
+
    Proposed resolution:
    
 
    
-Throws: Nothing.
+Change 20.8.15.3 [util.smartptr.weak]/1 as indicated:
 
    
 
-
    
-
    
+
    namespace std {
+template<class T> class weak_ptr {
+public:
+...
+  // comparisons
+  template<class Y> bool operator<(weak_ptr<Y> const&) const = delete;
+  template<class Y> bool operator<=(weak_ptr<Y> const&) const = delete;
+  template<class Y> bool operator>(weak_ptr<Y> const&) const = delete;
+  template<class Y> bool operator>=(weak_ptr<Y> const&) const = delete;
+};
+...
+
    
 
 
 
 
 
 
    
-
    1184. Feature request: dynamic bitset
    
-
    Section: 23.3.6 [vector] Status: New
- Submitter: Alisdair Meredith Opened: 2009-07-29  Last modified: 2009-07-29
    
-
    View other active issues in [vector].
    
-
    View all other issues in [vector].
    
+
    1257. Header <ios> still contains a concept_map
    
+
    Section: 27.5 [iostreams.base] Status: New
+ Submitter: Beman Dawes Opened: 2009-11-04  Last modified: 2009-11-04
    
+
    View all other issues in [iostreams.base].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-Opened at Alisdair's request, steming from 96.
-Alisdair recommends NAD Future.
+The current WP still contains a concept_map.
 
    
 
 
 
    Proposed resolution:
    
+
    
+Change Iostreams base classes 27.5 [iostreams.base], Header <ios> synopsis, 
+as indicated:
+
    
+
+
    concept_map ErrorCodeEnum<io_errc> { };
+template <> struct is_error_code_enum<io_errc> : true_type { }
+error_code make_error_code(io_errc e);
+error_condition make_error_condition(io_errc e);
+const error_category& iostream_category();
+
    
+
 
 
 
 
 
 
    
-
    1185. iterator categories and output iterators
    
-
    Section: X [iterator.requirements] Status: New
- Submitter: Alisdair Meredith Opened: 2009-07-31  Last modified: 2009-07-31
    
+
    1258. std::function Effects clause impossible to satisfy
    
+
    Section: 20.7.15.2.2 [func.wrap.func.mod] Status: New
+ Submitter: Daniel Krügler Opened: 2009-11-05  Last modified: 2009-11-05
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-(wording relative to
-N2723
-pending new working paper)
+As of 20.7.15.2.2 [func.wrap.func.mod]/2+ we have the following
+prototype description:
 
    
 
+
    template<class F, Allocator Alloc>
+  requires Callable<F, ArgTypes...>
+    && Convertible<Callable<F, ArgTypes...>::result_type, R>
+  void assign(F, const Alloc&);
+
    
+
    
+Effects: function(f, a).swap(*this)
+
    
+
    
+
 
    
-According to p3 X [iterator.requirements], Forward iterators,
-Bidirectional iterators and Random Access iterators all satisfy the
-requirements for an Output iterator:
+Two things: First the concept debris needs to be removed, second and
+much more importantly, the effects clause is now impossible to satisfy,
+because there is no constructor that would match the parameter sequence
+(FunctionObject, Allocator) [plus the fact that no
+f and no a is part of the signature]. The most
+probable candidate is
 
    
 
-
    
-XXX iterators satisfy all the requirements of the input and output iterators
-and can be used whenever either kind is specified ...
-
    
+
    template<class F, class A> function(allocator_arg_t, const A&, F);
+
    
 
 
    
-Meanwhile, p4 goes on to contradict this:
+and the effects clause needs to be adapted to use this signature.
 
    
 
-
    
-Besides its category, a forward, bidirectional, or random access
-iterator can also be mutable or constant...
-
    
 
+
    Proposed resolution:
    
+
    
+Change in 20.7.15.2.2 [func.wrap.func.mod] the complete prototype description as
+indicated
+
    
+
    [
+Question to
+the editor: Shouldn't there a paragraph number in front of the Effects clause?
+]
    
+
+
+
    template<class F, Allocator Alloc>
+  requires Callable<F, ArgTypes...>
+    && Convertible<Callable<F, ArgTypes...>::result_type, R>
+  void assign(F, const Alloc&);
+template<class F, class A> void assign(F f, const A& a);
+
    
 
    
-... Constant iterators do not satisfy the requirements for output iterators
+3 Effects: function(f, aallocator_arg, a,
+f).swap(*this)
+
    
 
    
 
-
    
-The latter seems to be the overriding concern, as the iterator tag
-hierarchy does not define forward_iterator_tag as multiply derived from
-both input_iterator_tag and output_iterator_tag.
-
    
 
+
+
+
+
    
+
    1259. Should initializer-list constructors move elements?
    
+
    Section: 23.2.3 [sequence.reqmts] Status: New
+ Submitter: Sean Hunt Opened: 2009-11-05  Last modified: 2009-11-06
    
+
    View other active issues in [sequence.reqmts].
    
+
    View all other issues in [sequence.reqmts].
    
+
    View all issues with New status.
    
+
    Discussion:
    
 
    
-The work on concepts for iterators showed us that output iterator really
-is fundamentally a second dimension to the iterator categories, rather
-than part of the linear input -> forward -> bidirectional ->
-random-access sequence.  It would be good to clear up these words to
-reflect that, and separately list output iterator requirements in the
-requires clauses for the appropriate algorithms and operations.
+According to 23.2.3 [sequence.reqmts], X(il) is
+equivalent to X(il.begin(), il.end()). Should it instead be
+equivalent to X(move_iterator(il.begin()),
+move_iterator(il.end())) so that needless copies are not made? This
+doesn't seem ideal either - it may make more sense to provide two
+overloads for the constructor, one for move and one for copy.
 
    
 
 
 
    Proposed resolution:
    
+
    
+
    
 
 
 
 
 
 
    
-
    1186. Forward list could model a stack
    
-
    Section: 23.3.5.3 [stack] Status: New
- Submitter: Alisdair Meredith Opened: 2009-07-31  Last modified: 2009-08-01
    
+
    1260. is_constructible<int*,void*> reports true
    
+
    Section: 20.6.4.3 [meta.unary.prop] Status: New
+ Submitter: Peter Dimov Opened: 2009-11-07  Last modified: 2009-11-08
    
+
    View other active issues in [meta.unary.prop].
    
+
    View all other issues in [meta.unary.prop].
    
 
    View all issues with New status.
    
 
    Discussion:
    
 
    
-The library template forward_list could easily model the idea of a
-stack, where the operations work on the front of the list rather than
-the back.  However, the standard library stack adaptor cannot support
-this.
+The specification of is_constructible<T,Args...> in
+N3000
+uses
 
    
 
+
    static_cast<T>(create<Args>()...)
+
    
+
 
    
-It would be relatively easy to write a partial specialization for stack
-to support forward_list, but that opens the question of which header to
-place it in.  A much better solution would be to add a concept_map for
-the StackLikeContainer concept to the <forward_list> header and then
-everything just works, including a user's own further uses in a
-stack-like context.
+for the one-argument case, but static_cast also permits
+unwanted conversions such as void* to T* and
+Base* to Derived*.
 
    
 
+
+
    Proposed resolution:
    
 
    
-Therefore while I am submitting the issue now so that it is on record, I
-strongly recommend we resolve as "NAD Concepts" as any non-concepts
-based solution will be inferior to the final goal, and the feature is
-not so compelling it must be supported ahead of the concepts-based
-library.
+Change 20.6.4.3 [meta.unary.prop], p6:
 
    
 
+
    
+
    
+the predicate condition for a template specialization
+is_constructible<T, Args> shall be satisfied, if and only
+if the following expression CE variable
+definition would be well-formed:
+
    
 
-
    Proposed resolution:
    
+
      
+
    • 
+
      
+if sizeof...(Args) == 0 1, the expression:
+
      
+
      static_cast<T>(create<Args>()...)
+T t;
+
      
+
      • 
+
    • 
+
      
+otherwise the expression:
+
      
+
      T t(create<Args>()...);
+
      
+
      • 
+
    
+
    
 
 
 
diff --git a/libstdc++-v3/doc/html/ext/lwg-closed.html b/libstdc++-v3/doc/html/ext/lwg-closed.html
index ce7faf5fccc..7839575d728 100644
--- a/libstdc++-v3/doc/html/ext/lwg-closed.html
+++ b/libstdc++-v3/doc/html/ext/lwg-closed.html
@@ -7,6 +7,14 @@
 
@@ -14,11 +22,11 @@ del {background-color:#FFA0A0}
 
-
+
-
+
@@ -29,7 +37,7 @@ del {background-color:#FFA0A0}
 
    
 
    
 Doc. no.N2942=09-0132N3013=09-0203
 
    
 
    
 Date:2009-08-022009-11-08
 
    
 
    
 Project:Howard Hinnant <howard.hinnant@gmail.com>
 
    
 
    
-
    C++ Standard Library Closed Issues List (Revision R66)
    
+
    C++ Standard Library Closed Issues List (Revision R68)
    
 
   
    Reference ISO/IEC IS 14882:2003(E)
    
   
    Also see:
    
@@ -51,6 +59,76 @@ del {background-color:#FFA0A0}
 
 
    Revision History
    
 
@@ -112,24 +190,24 @@ del {background-color:#FFA0A0}
 
  • 1143 issues total, up by 32.
    • 
 
 
  • Details:
    • 
 
 
@@ -142,7 +220,7 @@ del {background-color:#FFA0A0}
 
  • 1111 issues total, up by 19.
    • 
 
 
  • Details:
    • 
@@ -159,9 +237,9 @@ del {background-color:#FFA0A0}
 
  • Details:
    • 
 
@@ -192,7 +270,7 @@ del {background-color:#FFA0A0}
 
  • 982 issues total, up by 44.
    • 
 
 
  • Details:
    • 
 
 
@@ -205,7 +283,7 @@ del {background-color:#FFA0A0}
 
  • 938 issues total, up by 20.
    • 
 
 
  • Details:
    • 
 
 
@@ -219,28 +297,28 @@ del {background-color:#FFA0A0}
 
 
  • Details:
    • 
 
@@ -254,7 +332,7 @@ del {background-color:#FFA0A0}
 
  • 878 issues total, up by 9.
    • 
 
 
  • Details:
    • 
 
 
@@ -285,21 +363,21 @@ del {background-color:#FFA0A0}
 
 
  • Details:
    • 
 
  • Details:
    • 
 
@@ -331,7 +409,7 @@ del {background-color:#FFA0A0}
 
  • Details:
    • 
 
  • Details:
      
 
    • Added the following New issues: 755, 756, 757, 758, 759, 760, 761, 762, 763, 764.
      • 
-
    • Changed the following issues from NAD to Open: 463.
      • 
+
    • Changed the following issues from NAD to Open: 463.
      • 
 
    • Changed the following issues from Pending WP to WP: 607, 608, 654, 655, 677, 682.
      • 
 
    • 
 
@@ -402,7 +480,7 @@ del {background-color:#FFA0A0}
 
  • Changed the following issues from NAD Future to Dup: 77, 350.
    • 
 
  • Changed the following issues from New to NAD: 639, 657, 663.
    • 
 
  • Changed the following issues from Open to NAD: 548.
    • 
-
  • Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
    • 
+
  • Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
    • 
 
  • Changed the following issues from New to Pending NAD Editorial: 393, 592.
    • 
 
  • Changed the following issues from New to Pending WP: 607, 608, 654, 655, 677, 682.
    • 
 
  • Changed the following issues from New to Ready: 561, 562, 563, 567, 581, 595, 620, 621, 622, 623, 624, 661, 664, 665, 666, 674, 675, 676, 679, 687, 688, 689, 693, 694, 695, 700, 703, 705, 706.
    • 
@@ -423,7 +501,7 @@ del {background-color:#FFA0A0}
 
  • 723 issues total, up by 15.
    • 
 
 
  • Details:
    • 
 
 
@@ -463,7 +541,7 @@ del {background-color:#FFA0A0}
 
  • 696 issues total, up by 20.
    • 
 
 
  • Details:
    • 
 
  • Details:
    • 
 
  • Details:
    • 
 
@@ -525,7 +603,7 @@ del {background-color:#FFA0A0}
 
  • 619 issues total, up by 10.
    • 
 
 
  • Details:
    • 
 
 
@@ -557,7 +635,7 @@ del {background-color:#FFA0A0}
 
  • 592 issues total, up by 5.
    • 
 
 
  • Details:
    • 
 
 
@@ -570,7 +648,7 @@ del {background-color:#FFA0A0}
 
  • 587 issues total, up by 13.
    • 
 
 
  • Details:
    • 
@@ -587,7 +665,7 @@ del {background-color:#FFA0A0}
 
  • Details:
    • 
 
  • Details:
    • 
@@ -618,7 +696,7 @@ del {background-color:#FFA0A0}
 
  • 535 issues total.
    • 
 
 
  • Details:
    • 
 
 
@@ -627,7 +705,7 @@ del {background-color:#FFA0A0}
 Added new issues 526-528.
 Moved issues 280, 461, 464, 465, 467, 468, 474, 496 from Ready to WP as per the vote from Mont Tremblant.
 Moved issues 247, 294, 342, 362, 369, 371, 376, 384, 475, 478, 495, 497 from Review to Ready.
-Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open.
+Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open.
 Moved issues 505, 507, 508, 519 from New to Ready.
 Moved issue 500 from New to NAD.
 Moved issue 518 from New to Review.
@@ -639,7 +717,7 @@ Added new issues 498-503.
+Added new issues 498-503.
 
 
  • R36: 
 2005-04 post-Lillehammer mailing. All issues in "ready" status except
@@ -663,7 +741,7 @@ new issues 463-478.
+new issues 463-478.
 
    • 
 
  • R30: 
 Post-Sydney mailing: reflects decisions made at the Sydney meeting.
@@ -678,7 +756,7 @@ Post-Kona mailing: reflects decisions made at the Kona meeting.
 Added new issues 432-440.
 
    • 
 
  • R27: 
-Pre-Kona mailing.  Added new issues 404-431.
+Pre-Kona mailing.  Added new issues 404-431.
 
    • 
 
  • R26: 
 Post-Oxford mailing: reflects decisions made at the Oxford meeting.
@@ -862,7 +940,7 @@ format, 2. Auto_ptr conversions effects incorrect
-
    Section: D.9.1.3 [auto.ptr.conv] Status: NAD
+
    Section: D.10.1.3 [auto.ptr.conv] Status: NAD
  Submitter: Nathan Myers Opened: 1997-12-04  Last modified: 2006-12-29
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -962,9 +1040,8 @@ intended here. 
    
 
 
    
 
    12. Way objects hold allocators unclear
    
-
    Section: X [allocator.requirements] Status: NAD
+
    Section: 20.2.2 [allocator.requirements] Status: NAD
  Submitter: Angelika Langer Opened: 1998-02-23  Last modified: 2006-12-30
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -1065,7 +1142,7 @@ this is the intent of the LWG.
    
 
 
    
 
    65. Underspecification of strstreambuf::seekoff
    
-
    Section: D.7.1.3 [depr.strstreambuf.virtuals] Status: NAD
+
    Section: D.8.1.3 [depr.strstreambuf.virtuals] Status: NAD
  Submitter: Matt Austern Opened: 1998-08-18  Last modified: 2006-12-27
    
 
    View all other issues in [depr.strstreambuf.virtuals].
    
 
    View all issues with NAD status.
    
@@ -1238,6 +1315,7 @@ otherwise possible. 
    
 
    82. Missing constant for set elements
    
 
    Section: 23.2.4 [associative.reqmts] Status: NAD
  Submitter: Nico Josuttis Opened: 1998-09-29  Last modified: 2007-01-15
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -1468,7 +1546,7 @@ may be provided by a non-Standard implementation class:
    
 
 
 
    Proposed resolution:
    
-
    Add a new subclause [presumably 17.4.4.9] following 17.6.4.10 [res.on.exception.handling]:
    
+
    Add a new subclause [presumably 17.4.4.9] following 17.6.4.11 [res.on.exception.handling]:
    
 
 
    
   
    17.4.4.9 Template Parameters
     
    A specialization of a
@@ -1549,6 +1627,196 @@ illegal.  See 17.6.4.5 [member.functions] paragraph 2.
    
 
 
 
+
    
+
    96. Vector<bool> is not a container
    
+
    Section: 23.3.6 [vector] Status: NAD
+ Submitter: AFNOR Opened: 1998-10-07  Last modified: 2009-10-26
    
+
    View all other issues in [vector].
    
+
    View all issues with NAD status.
    
+
    Discussion:
    
+
    vector<bool> is not a container as its reference and
+pointer types are not references and pointers. 
    
+
+
    Also it forces everyone to have a space optimization instead of a
+speed one.
    
+
+
    See also: 99-0008 == N1185 Vector<bool> is
+Nonconforming, Forces Optimization Choice.
    
+
+
    [In Santa Cruz the LWG felt that this was Not A Defect.]
    
+
+
+
    [In Dublin many present felt that failure to meet Container
+requirements was a defect. There was disagreement as to whether
+or not the optimization requirements constituted a defect.]
    
+
+
+
    [The LWG looked at the following resolutions in some detail:
+
    
+     * Not A Defect.
    
+     * Add a note explaining that vector<bool> does not meet
+Container requirements.
    
+     * Remove vector<bool>.
    
+     * Add a new category of container requirements which
+vector<bool> would meet.
    
+     * Rename vector<bool>.
    
+
    
+No alternative had strong, wide-spread, support and every alternative
+had at least one "over my dead body" response.
    
+
    
+There was also mention of a transition scheme something like (1) add
+vector_bool and deprecate vector<bool> in the next standard. (2)
+Remove vector<bool> in the following standard.]
    
+
+
+
    [Modifying container requirements to permit returning proxies
+(thus allowing container requirements conforming vector<bool>)
+was also discussed.]
    
+
+
+
    [It was also noted that there is a partial but ugly workaround in
+that vector<bool> may be further specialized with a customer
+allocator.]
    
+
+
+
    [Kona: Herb Sutter presented his paper J16/99-0035==WG21/N1211,
+vector<bool>: More Problems, Better Solutions. Much discussion
+of a two step approach: a) deprecate, b) provide replacement under a
+new name.  LWG straw vote on that: 1-favor, 11-could live with, 2-over
+my dead body.  This resolution was mentioned in the LWG report to the
+full committee, where several additional committee members indicated
+over-my-dead-body positions.]
    
+
+
+
    Discussed at Lillehammer.  General agreement that we should
+  deprecate vector<bool> and introduce this functionality under
+  a different name, e.g. bit_vector.  This might make it possible to
+  remove the vector<bool> specialization in the standard that comes
+  after C++0x. There was also a suggestion that
+  in C++0x we could additional say that it's implementation defined
+  whether vector<bool> refers to the specialization or to the
+  primary template, but there wasn't general agreement that this was a
+  good idea.
    
+
+
    We need a paper for the new bit_vector class.
    
+
+
    [
+Batavia:
+]
    
+
+
    
+The LWG feels we need something closer to SGI's bitvector to ease migration
+from vector<bool>.  Although some of the funcitonality from
+N2050
+could well be used in such a template.  The concern is easing the API migration for those
+users who want to continue using a bit-packed container.  Alan and Beman to work.
+
    
+
+
    [
+Post Summit Alisdair adds:
+]
    
+
+
+
    
+
    
+vector<bool> is now a conforming container under the revised terms of C++0x,
+which supports containers of proxies.
+
    
+
    
+Recommend NAD.
+
    
+
    
+Two issues remain:
+
    
+
    
+i/ premature optimization in the specification.
+There is still some sentiment that deprecation is the correct way to go,
+although it is still not clear what it would mean to deprecate a single
+specialization of a template.
+
    
+
    
+Recommend: Create a new issue for the discussion, leave as Open.
+
    
+
    
+ii/ Request for a new bitvector class to guarantee the optimization, perhaps
+with a better tuned interface.
+
    
+
    
+This is a clear extension request that may be handled via a future TR.
+
    
+
    
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+We note that most of this issue has become moot over time,
+and agree with Alisdair's recommendations.
+Move to NAD Future for reconsideration of part (ii).
+
    
+
+
    [
+2009-07-29 Alisdair reopens:
+]
    
+
+
+
    
+
    
+This infamous issue was closed as NAD Future when concepts introduced
+support for proxy iterators, so the only remaining requirement was to
+provide a better type to support bitsets of dynamic length.  I fear we
+must re-open this issue until the post-concept form of iterators is
+available, and hopefully will support the necessary proxy functionality
+to allow us to close this issue as NAD.
+
    
+
+
    
+I recommend we spawn a separate issue (1184) requesting a dynamic length bitset
+and pre-emptively file it as NAD Future.  It is difficult to resolve #96
+when it effectively contains two separate sub-issues.
+
    
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Mark as NAD, and give rationale.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+We now have:
+N2050
+and
+N2160.
+
    
+
+
+
+
    Rationale:
    
+
    
+We want to support proxy iterators but that is going to be separate
+work. Don't want to see this issue come back in these kinds of terms.
+We're interested in a separate container, and proxy iterators, but both
+of those are separate issues.
+
    
+
    
+We've looked at a lot of ways to fix this that would be close to this,
+but those things would break existing code. Attempts to fix this
+directly have not been tractable, and removing it has not been
+tractable. Therefore we are closing.
+
    
+
+
+
+
+
 
    
 
    97. Insert inconsistent definition
    
 
    Section: 23 [containers] Status: NAD
@@ -1572,7 +1840,7 @@ the design, for better or for worse.
    
 
 
    
 
    99. Reverse_iterator comparisons completely wrong
    
-
    Section: 24.5.1.2.13 [reverse.iter.op==] Status: NAD
+
    Section: 24.5.1.3.13 [reverse.iter.op==] Status: NAD
  Submitter: AFNOR Opened: 1998-10-07  Last modified: 2006-12-27
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -1594,9 +1862,8 @@ exactly what the Standard says.
    
 
 
    
 
    100. Insert iterators/ostream_iterators overconstrained
    
-
    Section: 24.7 [insert.iterators], 24.6.4 [ostreambuf.iterator] Status: NAD
+
    Section: 24.5.2 [insert.iterators], 24.6.4 [ostreambuf.iterator] Status: NAD
  Submitter: AFNOR Opened: 1998-10-07  Last modified: 2006-12-27
    
-
    View other active issues in [insert.iterators].
    
 
    View all other issues in [insert.iterators].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -1619,7 +1886,6 @@ incorrect code to work, rather than the other way around.
    
 
    101. No way to free storage for vector and deque
    
 
    Section: 23.3.6 [vector], 23.3.1 [array] Status: NAD
  Submitter: AFNOR Opened: 1998-10-07  Last modified: 2007-02-19
    
-
    View other active issues in [vector].
    
 
    View all other issues in [vector].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -1646,6 +1912,7 @@ expressed in a single line of code (where v is
 
    102. Bug in insert range in associative containers
    
 
    Section: 23.2.4 [associative.reqmts] Status: Dup
  Submitter: AFNOR Opened: 1998-10-07  Last modified: 2006-12-30
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with Dup status.
    
 
    Duplicate of: 264
    
@@ -1783,7 +2050,7 @@ Post Summit Daniel adds:
 Recommend NAD. The proposed wording would violate the axioms of
 concept requirement EqualityComparable axioms as part of concept InputIterator
 and more specifically it would violate the explicit wording of
-24.2.2 [input.iterators]/7:
+24.2.1 [input.iterators]/7:
 
    
 
 
    
@@ -1875,7 +2142,7 @@ desired functionality.
    
 
 
    
 
    116. bitset cannot be constructed with a const char*
    
-
    Section: 20.3.6 [template.bitset] Status: Dup
+
    Section: 20.3.7 [template.bitset] Status: Dup
  Submitter: Judy Ward Opened: 1998-11-06  Last modified: 2008-03-14
    
 
    View other active issues in [template.bitset].
    
 
    View all other issues in [template.bitset].
    
@@ -1921,13 +2188,13 @@ longer work.
    
 
 
 
    Proposed resolution:
    
-
    Add to 20.3.6 [template.bitset] a bitset constructor declaration
    
+
    Add to 20.3.7 [template.bitset] a bitset constructor declaration
    
 
 
    
   
    explicit bitset(const char*);
    
 
    
 
-
    and in Section 20.3.6.1 [bitset.cons] add:
    
+
    and in Section 20.3.7.1 [bitset.cons] add:
    
 
 
    
   
    explicit bitset(const char* str);
    
@@ -2060,6 +2327,7 @@ retained for future reference.
    
 
    131. list::splice throws nothing
    
 
    Section: 23.3.4.4 [list.ops] Status: NAD
  Submitter: Howard Hinnant Opened: 1999-03-06  Last modified: 2007-02-19
    
+
    View other active issues in [list.ops].
    
 
    View all other issues in [list.ops].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -2207,7 +2475,7 @@ reconsider for the next standard.
    
 
 
    
 
    143. C .h header wording unclear
    
-
    Section: D.5 [depr.c.headers] Status: NAD
+
    Section: D.6 [depr.c.headers] Status: NAD
  Submitter: Christophe de Dinechin Opened: 1999-05-04  Last modified: 2006-12-27
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -2293,7 +2561,7 @@ int main() {
 
 
    Proposed resolution:
    
 
-
    Replace D.5 [depr.c.headers] paragraph 2 with:
    
+
    Replace D.6 [depr.c.headers] paragraph 2 with:
    
 
 
    
 
@@ -2555,6 +2823,7 @@ ios_base::init to basic_ios::init().)
    
 
    188. valarray helpers missing augmented assignment operators
    
 
    Section: 26.6.2.6 [valarray.cassign] Status: NAD
  Submitter: Gabriel Dos Reis Opened: 1999-08-15  Last modified: 2008-03-11
    
+
    View all other issues in [valarray.cassign].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
    26.5.2.6 defines augmented assignment operators
@@ -2590,7 +2859,7 @@ operators.
    
 
 
    
 
    190. min() and max() functions should be std::binary_functions
    
-
    Section: 25.5.7 [alg.min.max] Status: NAD
+
    Section: 25.4.7 [alg.min.max] Status: NAD
  Submitter: Mark Rintoul Opened: 1999-08-26  Last modified: 2009-07-14
    
 
    View all other issues in [alg.min.max].
    
 
    View all issues with NAD status.
    
@@ -2634,7 +2903,7 @@ function objects.
    
 
 
    
 
    191. Unclear complexity for algorithms such as binary search
    
-
    Section: 25.5.3 [alg.binary.search] Status: NAD
+
    Section: 25.4.3 [alg.binary.search] Status: NAD
  Submitter: Nico Josuttis Opened: 1999-10-10  Last modified: 2006-12-27
    
 
    View all other issues in [alg.binary.search].
    
 
    View all issues with NAD status.
    
@@ -2665,6 +2934,7 @@ iterators.
    
 
    192. a.insert(p,t) is inefficient and overconstrained
    
 
    Section: 23.2.4 [associative.reqmts] Status: NAD
  Submitter: Ed Brey Opened: 1999-06-06  Last modified: 2006-12-30
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with NAD status.
    
 
    Duplicate of: 233
    
@@ -2833,9 +3103,8 @@ class  rdbuf() always returns the original streambuf, whereas the base
 
 
    
 
    197. max_size() underspecified
    
-
    Section: X [allocator.requirements], 23.2 [container.requirements] Status: NAD
+
    Section: 20.2.2 [allocator.requirements], 23.2 [container.requirements] Status: NAD
  Submitter: Andy Sawyer Opened: 1999-10-21  Last modified: 2006-12-30
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -2949,7 +3218,7 @@ and is not a defect.
    
 
 
    
 
    204. distance(first, last) when "last" is before "first"
    
-
    Section: 24.4 [iterator.operations] Status: NAD
+
    Section: 24.4.4 [iterator.operations] Status: NAD
  Submitter: Rintala Matti Opened: 2000-01-28  Last modified: 2008-09-30
    
 
    View other active issues in [iterator.operations].
    
 
    View all other issues in [iterator.operations].
    
@@ -2985,7 +3254,7 @@ category?
    
 
 
 
    Rationale:
    
-
    "Reachable" is defined in the standard in 24.2 [iterator.concepts] paragraph 6.
+
    "Reachable" is defined in the standard in X [iterator.concepts] paragraph 6.
 The definition is only in terms of operator++(). The LWG sees no defect in
 the standard.
    
 
@@ -3097,6 +3366,7 @@ or write floating point expressions as arguments.
    
 
    215. Can a map's key_type be const?
    
 
    Section: 23.2.4 [associative.reqmts] Status: NAD
  Submitter: Judy Ward Opened: 2000-02-29  Last modified: 2006-12-27
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -3178,7 +3448,7 @@ occurs additional places in the section, all requiring fixes.]
    
 
 
    
 
    218. Algorithms do not use binary predicate objects for default comparisons
    
-
    Section: 25.5 [alg.sorting] Status: NAD
+
    Section: 25.4 [alg.sorting] Status: NAD
  Submitter: Pablo Halpern Opened: 2000-03-06  Last modified: 2006-12-27
    
 
    View all other issues in [alg.sorting].
    
 
    View all issues with NAD status.
    
@@ -3214,7 +3484,7 @@ operator<.
    
 
 
    
 
    219. find algorithm missing version that takes a binary predicate argument
    
-
    Section: 25.3.5 [alg.find] Status: NAD
+
    Section: 25.2.5 [alg.find] Status: NAD
  Submitter: Pablo Halpern Opened: 2000-03-06  Last modified: 2009-07-14
    
 
    View all other issues in [alg.find].
    
 
    View all issues with NAD status.
    
@@ -3254,7 +3524,7 @@ Moved to NAD.
 
 
    Proposed resolution:
    
 
    
-
    In section 25.3.5 [alg.find], add a second prototype for find
+
    In section 25.2.5 [alg.find], add a second prototype for find
 (between the existing prototype and the prototype for find_if), as
 follows:
    
 
        template<class InputIterator, class T, class BinaryPredicate>
@@ -3319,7 +3589,7 @@ ie. the do_is() method as described in 22.4.1.1.2 [locale.ctype.virtual
 
 
    
 
    244. Must find's third argument be CopyConstructible?
    
-
    Section: 25.3.5 [alg.find] Status: NAD
+
    Section: 25.2.5 [alg.find] Status: NAD
  Submitter: Andrew Koenig Opened: 2000-05-02  Last modified: 2006-12-27
    
 
    View all other issues in [alg.find].
    
 
    View all issues with NAD status.
    
@@ -3362,7 +3632,6 @@ might reasonably pass an argument that is not Copy Constructible.
    
 
    245. Which operations on istream_iterator trigger input operations?
    
 
    Section: 24.6.1 [istream.iterator] Status: NAD
  Submitter: Andrew Koenig Opened: 2000-05-02  Last modified: 2006-12-27
    
-
    View other active issues in [istream.iterator].
    
 
    View all other issues in [istream.iterator].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -3396,6 +3665,7 @@ how many times find may invoke operator++.
    
 
    246. a.insert(p,t) is incorrectly specified
    
 
    Section: 23.2.4 [associative.reqmts] Status: Dup
  Submitter: Mark Rodgers Opened: 2000-05-19  Last modified: 2007-01-15
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with Dup status.
    
 
    Duplicate of: 233
    
@@ -3482,7 +3752,7 @@ Change the words "right after" to "immediately before".
    
 
 
    
 
    249. Return Type of auto_ptr::operator=
    
-
    Section: D.9.1 [auto.ptr] Status: NAD
+
    Section: D.10.1 [auto.ptr] Status: NAD
  Submitter: Joseph Gottman Opened: 2000-06-30  Last modified: 2006-12-29
    
 
    View all other issues in [auto.ptr].
    
 
    View all issues with NAD status.
    
@@ -3629,7 +3899,7 @@ signature.
    
 
 
    
 
    257. STL functional object and iterator inheritance.
    
-
    Section: 20.7.3 [base], D.10.2 [iterator.basic] Status: NAD
+
    Section: 20.7.3 [base], 24.4.2 [iterator.basic] Status: NAD
  Submitter: Robert Dick  Opened: 2000-08-17  Last modified: 2006-12-29
    
 
    View all other issues in [base].
    
 
    View all issues with NAD status.
    
@@ -3713,7 +3983,7 @@ want to pass temporaries as traits or tag types in generic code.
 
 
    
 
    267. interaction of strstreambuf::overflow() and seekoff()
    
-
    Section: D.7.1.3 [depr.strstreambuf.virtuals] Status: NAD
+
    Section: D.8.1.3 [depr.strstreambuf.virtuals] Status: NAD
  Submitter: Martin Sebor Opened: 2000-10-05  Last modified: 2007-01-15
    
 
    View all other issues in [depr.strstreambuf.virtuals].
    
 
    View all issues with NAD status.
    
@@ -3777,7 +4047,7 @@ behavior of the program is undefined.
 
    Proposed resolution:
    
 
 
-   
    Change the last sentence of D.7.1 [depr.strstreambuf] paragraph 4 from
    
+   
    Change the last sentence of D.8.1 [depr.strstreambuf] paragraph 4 from
    
 
       
    
       Otherwise, seeklow equals gbeg and seekhigh is either pend, if
@@ -3878,9 +4148,8 @@ necessary.
 
 
    
 
    277. Normative encouragement in allocator requirements unclear
    
-
    Section: X [allocator.requirements] Status: NAD
+
    Section: 20.2.2 [allocator.requirements] Status: NAD
  Submitter: Matt Austern Opened: 2000-11-07  Last modified: 2006-12-30
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -4123,7 +4392,7 @@ never referred to by the C++ standard.
    
 
 
    
 
    290. Requirements to for_each and its function object
    
-
    Section: 25.3.4 [alg.foreach] Status: NAD
+
    Section: 25.2.4 [alg.foreach] Status: NAD
  Submitter: Angelika Langer Opened: 2001-01-03  Last modified: 2009-07-14
    
 
    View all other issues in [alg.foreach].
    
 
    View all issues with NAD status.
    
@@ -4186,7 +4455,7 @@ of the library.
 
 
    
 
    293. Order of execution in transform algorithm
    
-
    Section: 25.4.4 [alg.transform] Status: NAD
+
    Section: 25.3.4 [alg.transform] Status: NAD
  Submitter: Angelika Langer Opened: 2001-01-04  Last modified: 2007-01-15
    
 
    View all other issues in [alg.transform].
    
 
    View all issues with NAD status.
    
@@ -4253,35 +4522,6 @@ wrapping it in an Input Iterator adaptor.
    
 
 
 
-
    
-
    296. Missing descriptions and requirements of pair operators
    
-
    Section: 20.3.3 [pairs] Status: NAD
- Submitter: Martin Sebor Opened: 2001-01-14  Last modified: 2006-12-27
    
-
    View other active issues in [pairs].
    
-
    View all other issues in [pairs].
    
-
    View all issues with NAD status.
    
-
    Discussion:
    
-
    The synopsis of the header <utility> in 20.3 [utility]
-lists the complete set of equality and relational operators for pair
-but the section describing the template and the operators only describes
-operator==() and operator<(), and it fails to mention
-any requirements on the template arguments. The remaining operators are
-not mentioned at all.
-
     
-
-
-
    Rationale:
    
-
    20.3.1 [operators] paragraph 10 already specifies the semantics.
-That paragraph says that, if declarations of operator!=, operator>,
-operator<=, and operator>= appear without definitions, they are
-defined as specified in 20.3.1 [operators].  There should be no user
-confusion, since that paragraph happens to immediately precede the
-specification of pair.
    
-
-
-
-
-
 
    
 
    302. Need error indication from codecvt<>::do_length
    
 
    Section: 22.4.1.5 [locale.codecvt.byname] Status: NAD
@@ -4355,9 +4595,8 @@ external characters, it stops.
    
 
 
    
 
    304. Must *a return an lvalue when a is an input iterator?
    
-
    Section: 24.2 [iterator.concepts] Status: NAD
+
    Section: X [iterator.concepts] Status: NAD
  Submitter: Dave Abrahams Opened: 2001-02-05  Last modified: 2008-09-30
    
-
    View other active issues in [iterator.concepts].
    
 
    View all other issues in [iterator.concepts].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -5093,7 +5332,7 @@ Ready state:
 
  • It should apply to both overloads of seekg.
    • 
 
  • tellg has similar issues, except that it should not call clear().
    • 
 
  • The point about clear() seems to apply to seekp().
    • 
-
  • Depending on the outcome of 419
+
  • Depending on the outcome of 419
 if the sentry
 sets failbit when it finds eofbit already set, then
 you can never seek away from the end of stream.
    • 
@@ -5289,7 +5528,7 @@ author.
 
 
 
    
-NAD. Handled by LWG 1178.
+NAD. Handled by LWG 1178.
 
    
 
 
@@ -5438,12 +5677,12 @@ consensus in the LWG for action.
 
 
    
 
    348. Minor issue with std::pair operator<
    
-
    Section: 20.3.3 [pairs] Status: Dup
+
    Section: 20.3.4 [pairs] Status: Dup
  Submitter: Andy Sawyer Opened: 2001-10-23  Last modified: 2008-01-05
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
 
    View all issues with Dup status.
    
-
    Duplicate of: 532
    
+
    Duplicate of: 532
    
 
    Discussion:
    
 
 
@@ -5454,7 +5693,7 @@ operator< on any pair type which contains a pointer.
 
 
 
    Proposed resolution:
    
-
    In 20.3.3 [pairs] paragraph 6, replace:
    
+
    In 20.3.4 [pairs] paragraph 6, replace:
    
 
        Returns: x.first < y.first || (!(y.first < x.first) && x.second <
         y.second).
 
    
@@ -5487,7 +5726,7 @@ operator< on any pair type which contains a pointer.
 
 
    
 
    350. allocator<>::address
    
-
    Section: 20.8.4.1 [allocator.members], X [allocator.requirements], 17.6.1.1 [contents] Status: Dup
+
    Section: 20.8.8.1 [allocator.members], 20.2.2 [allocator.requirements], 17.6.1.1 [contents] Status: Dup
  Submitter: Nathan Myers Opened: 2001-10-25  Last modified: 2007-10-11
    
 
    View all other issues in [allocator.members].
    
 
    View all issues with Dup status.
    
@@ -5552,7 +5791,7 @@ a.address(s) lines, respectively:
 
 
    Rationale:
    
 
    The LWG believes both examples are ill-formed.  The contained type
-is required to be CopyConstructible (X [utility.arg.requirements]), and that
+is required to be CopyConstructible (20.2.1 [utility.arg.requirements]), and that
 includes the requirement that &t return the usual types and
 values. Since allocators are intended to be used in conjunction with
 containers, and since the CopyConstructible requirements appear to
@@ -5580,7 +5819,7 @@ exhibiting a problem.
    
 
    
 In 20.7 [function.objects] the header <functional> synopsis declares
 the unary_negate and binary_negate function objects as struct.
-However in 20.7.11 [negators] the unary_negate and binary_negate
+However in 20.7.10 [negators] the unary_negate and binary_negate
 function objects are defined as class.  Given the context, they are
 not "basic function objects" like negate, so this is either a typo or
 an editorial oversight.
@@ -5591,7 +5830,7 @@ an editorial oversight.
 
 
 
    Proposed resolution:
    
-
    Change the synopsis to reflect the useage in 20.7.11 [negators]
    
+
    Change the synopsis to reflect the useage in 20.7.10 [negators]
    
 
 
    [Curaçao: Since the language permits "struct", the LWG
 views this as NAD. They suggest, however, that the Project Editor
@@ -5605,7 +5844,7 @@ might wish to make the change as editorial.]
    
 
 
    
 
    353. std::pair missing template assignment
    
-
    Section: 20.3.3 [pairs] Status: NAD Editorial
+
    Section: 20.3.4 [pairs] Status: NAD Editorial
  Submitter: Martin Sebor Opened: 2001-12-02  Last modified: 2008-01-05
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
@@ -6056,13 +6295,13 @@ those terms, does not appear in the standard.]
    
 
 
    
 
    367. remove_copy/remove_copy_if and Input Iterators
    
-
    Section: 25.4.8 [alg.remove] Status: NAD
+
    Section: 25.3.8 [alg.remove] Status: NAD
  Submitter: Anthony Williams Opened: 2002-05-13  Last modified: 2006-12-27
    
 
    View all other issues in [alg.remove].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
    
-remove_copy and remove_copy_if (25.4.8 [alg.remove]) permit their
+remove_copy and remove_copy_if (25.3.8 [alg.remove]) permit their
 input range to be marked with Input Iterators. However, since two
 operations are required against the elements to copy (comparison and
 assigment), when the input range uses Input Iterators, a temporary
@@ -6079,7 +6318,7 @@ result maintained, so the temporary is not required.
 Add "If InputIterator does not meet the requirements of forward
 iterator, then the value type of InputIterator must be copy
 constructible. Otherwise copy constructible is not required." to
-25.4.8 [alg.remove] paragraph 6.
+25.3.8 [alg.remove] paragraph 6.
 
    
 
 
@@ -6125,13 +6364,13 @@ part of the "Effects" paragraph.
 
 
    
 
    372. Inconsistent description of stdlib exceptions
    
-
    Section: 17.6.4.10 [res.on.exception.handling], 18.7.1 [type.info] Status: NAD
+
    Section: 17.6.4.11 [res.on.exception.handling], 18.7.1 [type.info] Status: NAD
  Submitter: Randy Maddox Opened: 2002-07-22  Last modified: 2006-12-27
    
 
    View all other issues in [res.on.exception.handling].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
-
    Paragraph 3 under clause 17.6.4.10 [res.on.exception.handling], Restrictions on
+
    Paragraph 3 under clause 17.6.4.11 [res.on.exception.handling], Restrictions on
 Exception Handling, states that "Any other functions defined in the
 C++ Standard Library that do not have an exception-specification may
 throw implementation-defined exceptions unless otherwise specified."
@@ -6422,7 +6661,7 @@ NAD without prejudice. Will reopen if proposed resolution is supplied.
 
    
 Many function templates have parameters that are passed by value;
 a typical example is find_if's pred parameter in
-25.3.5 [alg.find].  Are the corresponding template parameters
+25.2.5 [alg.find].  Are the corresponding template parameters
 (Predicate in this case) implicitly required to be
 CopyConstructible, or does that need to be spelled out explicitly?
 
    
@@ -6564,7 +6803,7 @@ provide their own comparison function object.
    
 
 
    
 
    390. CopyConstructible requirements too strict
    
-
    Section: X [utility.arg.requirements] Status: NAD Editorial
+
    Section: 20.2.1 [utility.arg.requirements] Status: NAD Editorial
  Submitter: Doug Gregor Opened: 2002-10-24  Last modified: 2008-03-14
    
 
    View other active issues in [utility.arg.requirements].
    
 
    View all other issues in [utility.arg.requirements].
    
@@ -6632,14 +6871,14 @@ that &t and &u return the address of t and u, respectively.
 
 
    
 
    392. 'equivalence' for input iterators
    
-
    Section: 24.2.2 [input.iterators] Status: NAD
+
    Section: 24.2.1 [input.iterators] Status: NAD
  Submitter: Corwin Joy Opened: 2002-12-11  Last modified: 2006-12-27
    
 
    View all other issues in [input.iterators].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
 
    
-In section 24.2.2 [input.iterators] table 72 -
+In section 24.2.1 [input.iterators] table 72 -
 'Input Iterator Requirements' we have as a postcondition of *a:
 "If a==b and (a, b) is in the domain of == then *a is equivalent to *b".
 
    
@@ -7419,12 +7658,12 @@ is not so clear (see list 3).
 List 1 -- Examples of (presumably) normative Notes:
 
    
 
-20.8.4.1 [allocator.members], p3,
    
-20.8.4.1 [allocator.members], p10,
    
+20.8.8.1 [allocator.members], p3,
    
+20.8.8.1 [allocator.members], p10,
    
 21.4.2 [string.cons], p11,
    
 22.3.1.2 [locale.cons], p11,
    
 23.3.2.3 [deque.modifiers], p2,
    
-25.5.7 [alg.min.max], p3,
    
+25.4.7 [alg.min.max], p3,
    
 26.4.6 [complex.ops], p15,
    
 27.6.2.4.3 [streambuf.virt.get], p7.
    
 
    
@@ -7435,7 +7674,7 @@ List 2 -- Examples of (presumably) informative Notes:
 18.6.1.3 [new.delete.placement], p3,
    
 21.4.6.6 [string::replace], p14,
    
 22.4.1.4.2 [locale.codecvt.virtuals], p3,
    
-25.3.4 [alg.foreach], p4,
    
+25.2.4 [alg.foreach], p4,
    
 26.4.5 [complex.member.ops], p1,
    
 27.5.2.5 [ios.base.storage], p6.
    
 
    
@@ -7548,6 +7787,115 @@ to
 
 
 
+
    
+
    431. Swapping containers with unequal allocators
    
+
    Section: 20.2.2 [allocator.requirements], 25 [algorithms] Status: NAD Editorial
+ Submitter: Matt Austern Opened: 2003-09-20  Last modified: 2009-10-26
    
+
    View all other issues in [allocator.requirements].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    Clause 20.2.2 [allocator.requirements] paragraph 4 says that implementations
+  are permitted to supply containers that are unable to cope with
+  allocator instances and that container implementations may assume
+  that all instances of an allocator type compare equal.  We gave
+  implementers this latitude as a temporary hack, and eventually we
+  want to get rid of it.  What happens when we're dealing with
+  allocators that don't compare equal?
+
    
+
+
    In particular: suppose that v1 and v2 are both
+  objects of type vector<int, my_alloc> and that
+  v1.get_allocator() != v2.get_allocator().  What happens if
+  we write v1.swap(v2)?  Informally, three possibilities:
    
+
+
    1. This operation is illegal.  Perhaps we could say that an
+  implementation is required to check and to throw an exception, or
+  perhaps we could say it's undefined behavior.
    
+
    2. The operation performs a slow swap (i.e. using three
+  invocations of operator=, leaving each allocator with its
+  original container.  This would be an O(N) operation.
    
+
    3. The operation swaps both the vectors' contents and their
+  allocators.  This would be an O(1) operation. That is:
    
+  
    
+  
        my_alloc a1(...);
+    my_alloc a2(...);
+    assert(a1 != a2);
+
+    vector<int, my_alloc> v1(a1);
+    vector<int, my_alloc> v2(a2);
+    assert(a1 == v1.get_allocator());
+    assert(a2 == v2.get_allocator());
+
+    v1.swap(v2);
+    assert(a1 == v2.get_allocator());
+    assert(a2 == v1.get_allocator());
+  
    
+  
    
+
+
    [Kona: This is part of a general problem.  We need a paper
+  saying how to deal with unequal allocators in general.]
    
+
+
+
    [pre-Sydney: Howard argues for option 3 in
+N1599.
+]
    
+
+
+
    [
+2007-01-12, Howard:  This issue will now tend to come up more often with move constructors
+and move assignment operators.  For containers, these members transfer resources (i.e.
+the allocated memory) just like swap.
+]
    
+
+
+
    [
+Batavia:  There is agreement to overload the container swap on the allocator's Swappable
+requirement using concepts.  If the allocator supports Swappable, then container's swap will
+swap allocators, else it will perform a "slow swap" using copy construction and copy assignment.
+]
    
+
+
+
    [
+2009-04-28 Pablo adds:
+]
    
+
+
    
+Fixed in
+N2525.
+I argued for marking this Tentatively-Ready right after Bellevue,
+but there was a concern that
+N2525
+would break in the presence of the RVO. (That breakage had nothing to do with
+swap, but never-the-less). I addressed that breakage in in
+N2840
+(Summit) by means of a non-normative reference:
+
+
    
+[Note: in situations where the copy constructor for a container is elided,
+this function is not called. The behavior in these cases is as if
+select_on_container_copy_construction returned x — end note]
+
    
+
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Addressed by
+N2982.
+
    
+
+
+
+
    Proposed resolution:
    
+
+
+
+
+
 
    
 
    433. Contradiction in specification of unexpected()
    
 
    Section: 18.8.2.4 [unexpected] Status: NAD
@@ -7800,6 +8148,7 @@ table, in this regard.
 
    451. Associative erase should return an iterator
    
 
    Section: 23.2.4 [associative.reqmts], 23.4 [associative] Status: Dup
  Submitter: Bill Plauger Opened: 2004-01-30  Last modified: 2009-05-01
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with Dup status.
    
 
    Duplicate of: 130
    
@@ -8065,6 +8414,104 @@ NAD.
 
 
 
+
    
+
    458. 24.1.5 contains unintended limitation for operator-
    
+
    Section: 24.2.5 [random.access.iterators] Status: NAD
+ Submitter: Daniel Frey Opened: 2004-02-27  Last modified: 2009-10-26
    
+
    View all other issues in [random.access.iterators].
    
+
    View all issues with NAD status.
    
+
    Discussion:
    
+
    
+In 24.1.5 [lib.random.access.iterators], table 76 the operational
+semantics for the expression "r -= n" are defined as "return r += -n".
+This means, that the expression -n must be valid, which is not the case
+for unsigned types.
+
    
+
+
    [
+Sydney: Possibly not a real problem, since difference type is required
+to be a signed integer type. However, the wording in the standard may
+be less clear than we would like.
+]
    
+
+
+
    [
+Post Summit Alisdair adds:
+]
    
+
+
+
    
+
    
+This issue refers to a requirements table we have removed.
+
    
+
    
+The issue might now relate to 24.2.5 [random.access.iterators] p5.
+However, the rationale in the issue already recognises that the
+difference_type must be signed, so this really looks NAD.
+
    
+
    
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+
    
+We agree with Alisdair's observations.
+
    
+
    
+Move to NAD.
+
    
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+
    
+Need to look at again without concepts.
+
    
+
    
+There was a question about this phrase in the discussion: "the
+expression -n must be valid, which is not the case for unsigned types."
+If n is an object ofthe iterator difference_type (eg ptrdiff_t), then it
+is never unsigned.
+
    
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+The group reviewed the wording in the draft and agreed that n is of
+difference type, the difference type is signed, and the current wording
+is correct.  Moved to NAD.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+To remove this limitation, I suggest to change the
+operational semantics for this column to:
+
    
+
        { Distance m = n;
+      if (m >= 0)
+        while (m--) --r;
+      else
+        while (m++) ++r;
+      return r; }
+
    
+
+
+
+
+
+
 
    
 
    459. Requirement for widening in stage 2 is overspecification
    
 
    Section: 22.4.2.1.2 [facet.num.get.virtuals] Status: NAD
@@ -8322,22 +8769,474 @@ Bill agrees issue is no longer serious, and accepts NAD.
 
 
 
    
-
    466. basic_string ctor should prevent null pointer error
    
-
    Section: 21.4.1 [string.require] Status: NAD
- Submitter: Daniel Frey Opened: 2004-06-10  Last modified: 2009-07-14
    
-
    View all other issues in [string.require].
    
+
    463. auto_ptr usability issues
    
+
    Section: D.10.1 [auto.ptr] Status: NAD
+ Submitter: Rani Sharoni Opened: 2003-12-07  Last modified: 2009-10-26
    
+
    View all other issues in [auto.ptr].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
+
 
    
-Today, my colleagues and me wasted a lot of time. After some time, I
-found the problem. It could be reduced to the following short example:
+TC1 CWG DR #84 effectively made the template<class Y> operator auto_ptr<Y>()
+member of auto_ptr (20.4.5.3/4) obsolete.
 
    
 
-
      #include <string>
-  int main() { std::string( 0 ); }
+
    
+The sole purpose of this obsolete conversion member is to enable copy
+initialization base from r-value derived (or any convertible types like
+cv-types) case:
+
    
+
    #include <memory>
+using std::auto_ptr;
+
+struct B {};
+struct D : B {};
+
+auto_ptr<D> source();
+int sink(auto_ptr<B>);
+int x1 = sink( source() ); // #1 EDG - no suitable copy constructor
 
    
 
-
    The problem is that the tested compilers (GCC 2.95.2, GCC 3.3.1 and
+
    
+The excellent analysis of conversion operations that was given in the final
+auto_ptr proposal
+(http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/1997/N1128.pdf)
+explicitly specifies this case analysis (case 4). DR #84 makes the analysis
+wrong and actually comes to forbid the loophole that was exploited by the
+auto_ptr designers.
+
    
+
+
    
+I didn't encounter any compliant compiler (e.g. EDG, GCC, BCC and VC) that
+ever allowed this case. This is probably because it requires 3 user defined
+conversions and in fact current compilers conform to DR #84.
+
    
+
+
    
+I was surprised to discover that the obsolete conversion member actually has
+negative impact of the copy initialization base from l-value derived
+case:
    
+
    auto_ptr<D> dp;
+int x2 = sink(dp); // #2 EDG - more than one user-defined conversion applies
+
    
+
+
    
+I'm sure that the original intention was allowing this initialization using
+the template<class Y> auto_ptr(auto_ptr<Y>& a) constructor (20.4.5.1/4) but
+since in this copy initialization it's merely user defined conversion (UDC)
+and the obsolete conversion member is UDC with the same rank (for the early
+overloading stage) there is an ambiguity between them.
+
    
+
+
    
+Removing the obsolete member will have impact on code that explicitly
+invokes it:
+
    
+
    int y = sink(source().operator auto_ptr<B>());
+
    
+
+
    
+IMHO no one ever wrote such awkward code and the reasonable workaround for
+#1 is:
+
    
+
    int y = sink( auto_ptr<B>(source()) );
+
    
+
+
    
+I was even more surprised to find out that after removing the obsolete
+conversion member the initialization was still ill-formed:
+int x3 = sink(dp); // #3 EDG - no suitable copy constructor
+
    
+
+
    
+This copy initialization semantically requires copy constructor which means
+that both template conversion constructor and the auto_ptr_ref conversion
+member (20.4.5.3/3) are required which is what was explicitly forbidden in
+DR #84. This is a bit amusing case in which removing ambiguity results with
+no candidates.
+
    
+
+
    
+I also found exception safety issue with auto_ptr related to auto_ptr_ref:
+
    
+
    int f(auto_ptr<B>, std::string);
+auto_ptr<B> source2();
+
+// string constructor throws while auto_ptr_ref
+// "holds" the pointer
+int x4 = f(source2(), "xyz"); // #4
+
    
+
+
    
+The theoretic execution sequence that will cause a leak:
+
    
+
      
+
    1. call auto_ptr<B>::operator auto_ptr_ref<B>()
      2. 
+
    2. call string::string(char const*) and throw
      3. 
+
    
+
+
    
+According to 20.4.5.3/3 and 20.4.5/2 the auto_ptr_ref conversion member
+returns auto_ptr_ref<Y> that holds *this and this is another defect since
+the type of *this is auto_ptr<X> where X might be different from Y. Several
+library vendors (e.g. SGI) implement auto_ptr_ref<Y> with Y* as member which
+is much more reasonable. Other vendor implemented auto_ptr_ref as
+defectively required and it results with awkward and catastrophic code:
+int oops = sink(auto_ptr<B>(source())); // warning recursive on all control
+paths
+
    
+
+
    
+Dave Abrahams noticed that there is no specification saying that
+auto_ptr_ref copy constructor can't throw.
+
    
+
+
    
+My proposal comes to solve all the above issues and significantly simplify
+auto_ptr implementation. One of the fundamental requirements from auto_ptr
+is that it can be constructed in an intuitive manner (i.e. like ordinary
+pointers) but with strict ownership semantics which yield that source
+auto_ptr in initialization must be non-const. My idea is to add additional
+constructor template with sole propose to generate ill-formed, diagnostic
+required, instance for const auto_ptr arguments during instantiation of
+declaration. This special constructor will not be instantiated for other
+types which is achievable using 14.8.2/2 (SFINAE). Having this constructor
+in hand makes the constructor template<class Y> auto_ptr(auto_ptr<Y> const&)
+legitimate since the actual argument can't be const yet non const r-value
+are acceptable.
+
    
+
+
    
+This implementation technique makes the "private auxiliary class"
+auto_ptr_ref obsolete and I found out that modern C++ compilers (e.g. EDG,
+GCC and VC) consume the new implementation as expected and allow all
+intuitive initialization and assignment cases while rejecting illegal cases
+that involve const auto_ptr arguments.
+
    
+
+
    The proposed auto_ptr interface:
    
+
+
    namespace std {
+    template<class X> class auto_ptr {
+    public:
+        typedef X element_type;
+
+        // 20.4.5.1 construct/copy/destroy:
+        explicit auto_ptr(X* p=0) throw();
+        auto_ptr(auto_ptr&) throw();
+        template<class Y> auto_ptr(auto_ptr<Y> const&) throw();
+        auto_ptr& operator=(auto_ptr&) throw();
+        template<class Y> auto_ptr& operator=(auto_ptr<Y>) throw();
+        ~auto_ptr() throw();
+
+        // 20.4.5.2 members:
+        X& operator*() const throw();
+        X* operator->() const throw();
+        X* get() const throw();
+        X* release() throw();
+        void reset(X* p=0) throw();
+
+    private:
+        template<class U>
+        auto_ptr(U& rhs, typename
+unspecified_error_on_const_auto_ptr<U>::type = 0);
+    };
+}
+
    
+
+
    
+One compliant technique to implement the unspecified_error_on_const_auto_ptr
+helper class is using additional private auto_ptr member class template like
+the following:
+
    
+
    template<typename T> struct unspecified_error_on_const_auto_ptr;
+
+template<typename T>
+struct unspecified_error_on_const_auto_ptr<auto_ptr<T> const>
+{ typedef typename auto_ptr<T>::const_auto_ptr_is_not_allowed type; };
+
    
+
+
    
+There are other techniques to implement this helper class that might work
+better for different compliers (i.e. better diagnostics) and therefore I
+suggest defining its semantic behavior without mandating any specific
+implementation. IMO, and I didn't found any compiler that thinks otherwise,
+14.7.1/5 doesn't theoretically defeat the suggested technique but I suggest
+verifying this with core language experts.
+
    
+
+
    Further changes in standard text:
    
+
    Remove section 20.4.5.3
    
+
+
    Change 20.4.5/2 to read something like:
+Initializing auto_ptr<X> from const auto_ptr<Y> will result with unspecified
+ill-formed declaration that will require unspecified diagnostic.
    
+
+
    Change 20.4.5.1/4,5,6 to read:
    
+
+
    template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();
    
+
     4 Requires: Y* can be implicitly converted to X*.
    
+
     5 Effects: Calls const_cast<auto_ptr<Y>&>(a).release().
    
+
     6 Postconditions: *this holds the pointer returned from a.release().
    
+
+
    Change 20.4.5.1/10
    
+
    template<class Y> auto_ptr& operator=(auto_ptr<Y> a) throw();
+
    
+
    
+10 Requires: Y* can be implicitly converted to X*. The expression delete
+get() is well formed.
+
    
+
+
    LWG TC DR #127 is obsolete.
    
+
+
    
+Notice that the copy constructor and copy assignment operator should remain
+as before and accept non-const auto_ptr& since they have effect on the form
+of the implicitly declared copy constructor and copy assignment operator of
+class that contains auto_ptr as member per 12.8/5,10:
+
    
+
    struct X {
+    // implicit X(X&)
+    // implicit X& operator=(X&)
+    auto_ptr<D> aptr_;
+};
+
    
+
+
    
+In most cases this indicates about sloppy programming but preserves the
+current auto_ptr behavior.
+
    
+
+
    
+Dave Abrahams encouraged me to suggest fallback implementation in case that
+my suggestion that involves removing of auto_ptr_ref will not be accepted.
+In this case removing the obsolete conversion member to auto_ptr<Y> and
+20.4.5.3/4,5 is still required in order to eliminate ambiguity in legal
+cases. The two constructors that I suggested will co exist with the current
+members but will make auto_ptr_ref obsolete in initialization contexts.
+auto_ptr_ref will be effective in assignment contexts as suggested in DR
+#127 and I can't see any serious exception safety issues in those cases
+(although it's possible to synthesize such). auto_ptr_ref<X> semantics will
+have to be revised to say that it strictly holds pointer of type X and not
+reference to an auto_ptr for the favor of cases in which auto_ptr_ref<Y> is
+constructed from auto_ptr<X> in which X is different from Y (i.e. assignment
+from r-value derived to base).
+
    
+
+
    [Redmond: punt for the moment. We haven't decided yet whether we
+  want to fix auto_ptr for C++-0x, or remove it and replace it with
+  move_ptr and unique_ptr.]
    
+
+
+
    [
+Oxford 2007: Recommend NAD.  We're just going to deprecate it.  It still works for simple use cases
+and people know how to deal with it.  Going forward unique_ptr is the recommended
+tool.
+]
    
+
+
+
    [
+2007-11-09: Reopened at the request of David Abrahams, Alisdair Meredith and Gabriel Dos Reis.
+]
    
+
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+This is a complicated issue, so we agreed to defer discussion until
+later in the week so that interested parties can read up on it.
+
    
+
+
    [
+209-10-04 Daniel adds:
+]
    
+
+
+
    
+
    
+I suggest to close this issue as NAD. The reasons are two-fold: First, the
+suggested proposed resolution uses no longer appropriate language means
+to solve this issue, which has the effect that the recommended resolution is
+another - but better - form of hack. Second, either following the suggested
+resolution or the now more natural alternative via the added member set
+
    
+
+
    template<class Y> auto_ptr(auto_ptr<Y>&&) throw();
+template<class Y> auto_ptr& operator=(auto_ptr<Y>&&) throw();
+
    
+
+
    
+would still have a non-zero probability to break user-code that actively
+references auto_ptr_ref. This risk seems to indicate that a
+decision which would not touch the current spec of auto_ptr at
+all (but deprecating it) and instead recommending to use
+unique_ptr for new code instead might have the best
+cost-benefit ratio. IMO the current solution of 1100 can
+be considered as an active user-support for this transition.
+
    
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Mark as NAD. Alisdair will open a new issue (1247) with
+proposed wording to handle auto_ptr_ref.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change the synopsis in D.10.1 [auto.ptr]:
+
    
+
+
    namespace std { 
+  template <class Y> struct auto_ptr_ref {};
+
+  // exposition only
+  template <class T> struct constant_object;
+
+  // exposition only
+  template <class T>
+  struct cannot_transfer_ownership_from
+    : constant_object<T> {};
+
+  template <class X> class auto_ptr { 
+  public: 
+    typedef X element_type; 
+
+    // D.9.1.1 construct/copy/destroy: 
+    explicit auto_ptr(X* p =0) throw(); 
+    auto_ptr(auto_ptr&) throw(); 
+    template<class Y> auto_ptr(auto_ptr<Y> const&) throw(); 
+    auto_ptr& operator=(auto_ptr&) throw(); 
+    template<class Y> auto_ptr& operator=(auto_ptr<Y>&) throw();
+    auto_ptr& operator=(auto_ptr_ref<X> r) throw();
+    ~auto_ptr() throw(); 
+
+    // D.9.1.2 members: 
+    X& operator*() const throw();
+    X* operator->() const throw();
+    X* get() const throw();
+    X* release() throw();
+    void reset(X* p =0) throw();
+
+    // D.9.1.3 conversions:
+    auto_ptr(auto_ptr_ref<X>) throw();
+    template<class Y> operator auto_ptr_ref<Y>() throw();
+    template<class Y> operator auto_ptr<Y>() throw();
+
+    // exposition only
+    template<class U>
+    auto_ptr(U& rhs, typename cannot_transfer_ownership_from<U>::error = 0);
+  }; 
+
+  template <> class auto_ptr<void> 
+  { 
+  public: 
+    typedef void element_type; 
+  }; 
+
+}
+
    
+
+
    
+Remove D.10.1.3 [auto.ptr.conv].
+
    
+
+
    
+Change D.10.1 [auto.ptr], p3:
+
    
+
+
    
+The auto_ptr provides a semantics of strict ownership. An
+auto_ptr owns the object it holds a pointer to. Copying an
+auto_ptr copies the pointer and transfers ownership to the
+destination. If more than one auto_ptr owns the same object at
+the same time the behavior of the program is undefined. Templates
+constant_object and cannot_transfer_ownership_from,
+and the final constructor of auto_ptr are for exposition only.
+For any types X and Y, initializing
+auto_ptr<X> from const auto_ptr<Y> is
+ill-formed, diagnostic required. [Note: The uses of
+auto_ptr include providing temporary exception-safety for
+dynamically allocated memory, passing ownership of dynamically allocated
+memory to a function, and returning dynamically allocated memory from a
+function. auto_ptr does not meet the CopyConstructible
+and Assignable requirements for Standard Library container
+elements and thus instantiating a Standard Library container with an
+auto_ptr results in undefined behavior. -- end note]
+
    
+
+
    
+Change D.10.1.1 [auto.ptr.cons], p5:
+
    
+
+
    
+
    template<class Y> auto_ptr(auto_ptr<Y> const& a) throw();
+
    
+
    
+
    
+Requires: Y* can be implicitly converted to X*.
+
    
+
    
+Effects: Calls const_cast<auto_ptr<Y>&>(a).release().
+
    
+
    
+Postconditions: *this holds the pointer returned from a.release().
+
    
+
    
+
    
+
+
    
+Change D.10.1.1 [auto.ptr.cons], p10:
+
    
+
+
    
+
    template<class Y> auto_ptr& operator=(auto_ptr<Y>& a) throw();
+
    
+
    
+
    
+Requires: Y* can be implicitly converted to X*.
+The expression delete get() is well formed.
+
    
+
    
+Effects: Calls reset(a.release()).
+
    
+
    
+Returns: *this.
+
    
+
    
+
    
+
+
+
+
+
+
+
    
+
    466. basic_string ctor should prevent null pointer error
    
+
    Section: 21.4.1 [string.require] Status: NAD
+ Submitter: Daniel Frey Opened: 2004-06-10  Last modified: 2009-07-14
    
+
    View all other issues in [string.require].
    
+
    View all issues with NAD status.
    
+
    Discussion:
    
+
    
+Today, my colleagues and me wasted a lot of time. After some time, I
+found the problem. It could be reduced to the following short example:
+
    
+
+
      #include <string>
+  int main() { std::string( 0 ); }
+
    
+
+
    The problem is that the tested compilers (GCC 2.95.2, GCC 3.3.1 and
 Comeau online) compile the above without errors or warnings! The
 programs (at least for the GCC) resulted in a SEGV.
    
 
@@ -8465,7 +9364,7 @@ corner cases.
 
 
    
 
    472. Missing "Returns" clause in std::equal_range
    
-
    Section: 25.5.3.3 [equal.range] Status: Dup
+
    Section: 25.4.3.3 [equal.range] Status: Dup
  Submitter: Prateek R Karandikar Opened: 2004-06-30  Last modified: 2006-12-30
    
 
    View all other issues in [equal.range].
    
 
    View all issues with Dup status.
    
@@ -8489,7 +9388,7 @@ There is no "Returns:" clause for std::equal_range, which returns non-void.
 
 
    
 
    476. Forward Iterator implied mutability
    
-
    Section: 24.2.4 [forward.iterators] Status: NAD
+
    Section: 24.2.3 [forward.iterators] Status: NAD
  Submitter: Dave Abrahams Opened: 2004-07-09  Last modified: 2007-01-15
    
 
    View all other issues in [forward.iterators].
    
 
    View all issues with NAD status.
    
@@ -8529,7 +9428,7 @@ overhaul.)
    
 
 
    
 
    477. Operator-> for const forward iterators
    
-
    Section: 24.2.4 [forward.iterators] Status: Dup
+
    Section: 24.2.3 [forward.iterators] Status: Dup
  Submitter: Dave Abrahams Opened: 2004-07-11  Last modified: 2007-01-15
    
 
    View all other issues in [forward.iterators].
    
 
    View all issues with Dup status.
    
@@ -8587,7 +9486,7 @@ as the first line.
    
 
    View other active issues in [container.requirements].
    
 
    View all other issues in [container.requirements].
    
 
    View all issues with Dup status.
    
-
    Duplicate of: 580
    
+
    Duplicate of: 580
    
 
    Discussion:
    
 
    Nothing in the standard appears to make this program ill-formed:
    
 
@@ -8696,7 +9595,7 @@ nonvirtual destructors.
    
 
 
    
 
    481. unique's effects on the range [result, last)
    
-
    Section: 25.4.9 [alg.unique] Status: NAD
+
    Section: 25.3.9 [alg.unique] Status: NAD
  Submitter: Andrew Koenig Opened: 2004-08-30  Last modified: 2006-12-27
    
 
    View all other issues in [alg.unique].
    
 
    View all issues with NAD status.
    
@@ -8733,7 +9632,7 @@ explicit, but it's hard to think that's a major problem.
    
 
 
    
 
    482. Swapping pairs
    
-
    Section: 20.3.3 [pairs], 20.5 [tuple] Status: NAD Editorial
+
    Section: 20.3.4 [pairs], 20.5 [tuple] Status: NAD Editorial
  Submitter: Andrew Koenig Opened: 2004-09-14  Last modified: 2007-05-06
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
@@ -8776,7 +9675,7 @@ Recommend NAD, fixed by
 
 
    
 
    483. Heterogeneous equality and EqualityComparable
    
-
    Section: 25.3 [alg.nonmodifying], 25.4 [alg.modifying.operations] Status: Dup
+
    Section: 25.2 [alg.nonmodifying], 25.3 [alg.modifying.operations] Status: Dup
  Submitter: Peter Dimov Opened: 2004-09-20  Last modified: 2007-01-15
    
 
    View all issues with Dup status.
    
 
    Duplicate of: 283
    
@@ -8879,9 +9778,97 @@ operator that takes a T, or a T may be convertible to the type of *i.
 
 
 
+
    
+
    484. Convertible to T
    
+
    Section: 24.2.1 [input.iterators] Status: NAD Future
+ Submitter: Chris Jefferson Opened: 2004-09-16  Last modified: 2009-10-26
    
+
    View all other issues in [input.iterators].
    
+
    View all issues with NAD Future status.
    
+
    Discussion:
    
+
    From comp.std.c++:
    
+
+
    
+I note that given an input iterator a for type T, 
+then *a only has to be "convertable to T", not actually of type T.
+
    
+
+
    Firstly, I can't seem to find an exact definition of "convertable to T". 
+While I assume it is the obvious definition (an implicit conversion), I 
+can't find an exact definition. Is there one?
    
+
+
    Slightly more worryingly, there doesn't seem to be any restriction on 
+the this type, other than it is "convertable to T". Consider two input 
+iterators a and b. I would personally assume that most people would 
+expect *a==*b would perform T(*a)==T(*b), however it doesn't seem that 
+the standard requires that, and that whatever type *a is (call it U) 
+could have == defined on it with totally different symantics and still 
+be a valid inputer iterator.
    
+
+
    Is this a correct reading? When using input iterators should I write 
+T(*a) all over the place to be sure that the object i'm using is the 
+class I expect?
    
+
+
    This is especially a nuisance for operations that are defined to be
+  "convertible to bool".  (This is probably allowed so that
+  implementations could return say an int and avoid an unnessary
+  conversion. However all implementations I have seen simply return a
+  bool anyway.  Typical implemtations of STL algorithms just write
+  things like while(a!=b && *a!=0).  But strictly
+  speaking, there are lots of types that are convertible to T but
+  that also overload the appropriate operators so this doesn't behave
+  as expected.
    
+
+
    If we want to make code like this legal (which most people seem to
+  expect), then we'll need to tighten up what we mean by "convertible
+  to T".
    
+
+
    [Lillehammer: The first part is NAD, since "convertible" is
+ well-defined in core. The second part is basically about pathological
+ overloads. It's a minor problem but a real one. So leave open for
+ now, hope we solve it as part of iterator redesign.]
    
+
+
+
    [
+2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Mark as NAD Future. We agree there's an issue, but there is no
+proposed solution at this time and this will be solved by concepts in
+the future.
+
    
+
+
+
+
    Proposed resolution:
    
+
+
+
    Rationale:
    
+
    [
+San Francisco:
+]
    
+
+
+
    
+Solved by
+N2758.
+
    
+
+
+
+
+
+
+
 
    
 
    486. min/max CopyConstructible requirement is too strict
    
-
    Section: 25.5.7 [alg.min.max] Status: Dup
+
    Section: 25.4.7 [alg.min.max] Status: Dup
  Submitter: Dave Abrahams Opened: 2004-10-13  Last modified: 2006-12-30
    
 
    View all other issues in [alg.min.max].
    
 
    View all issues with Dup status.
    
@@ -8904,9 +9891,8 @@ copy T.
    
 
 
    
 
    487. Allocator::construct is too limiting
    
-
    Section: X [allocator.requirements] Status: NAD
+
    Section: 20.2.2 [allocator.requirements] Status: NAD
  Submitter: Dhruv Matani Opened: 2004-10-17  Last modified: 2006-12-30
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -8949,7 +9935,7 @@ be called! Doesn't that sound great?
 
 
    
 
    489. std::remove / std::remove_if wrongly specified
    
-
    Section: 25.4.8 [alg.remove] Status: NAD
+
    Section: 25.3.8 [alg.remove] Status: NAD
  Submitter: Thomas Mang Opened: 2004-12-12  Last modified: 2006-12-27
    
 
    View all other issues in [alg.remove].
    
 
    View all issues with NAD status.
    
@@ -9148,7 +10134,7 @@ ISO/IEC 14882:2003.
 
 
    
 
    490. std::unique wrongly specified
    
-
    Section: 25.4.9 [alg.unique] Status: NAD
+
    Section: 25.3.9 [alg.unique] Status: NAD
  Submitter: Thomas Mang Opened: 2004-12-12  Last modified: 2006-12-27
    
 
    View all other issues in [alg.unique].
    
 
    View all issues with NAD status.
    
@@ -9401,6 +10387,7 @@ change, so there is no real-world harm here.
    
 
    491. std::list<>::unique incorrectly specified
    
 
    Section: 23.3.4.4 [list.ops] Status: NAD
  Submitter: Thomas Mang Opened: 2004-12-12  Last modified: 2007-02-19
    
+
    View other active issues in [list.ops].
    
 
    View all other issues in [list.ops].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -9818,7 +10805,7 @@ it doesn't cover. Bill will provide wording.]
    
 
 
    
 
    493. Undefined Expression in Input Iterator Note Title
    
-
    Section: 24.2.2 [input.iterators] Status: NAD
+
    Section: 24.2.1 [input.iterators] Status: NAD
  Submitter: Chris Jefferson Opened: 2004-12-13  Last modified: 2006-12-27
    
 
    View all other issues in [input.iterators].
    
 
    View all issues with NAD status.
    
@@ -9860,6 +10847,7 @@ not guarantee the substitution property or referential transparency).
    
 
    494. Wrong runtime complexity for associative container's insert and delete
    
 
    Section: 23.2.4 [associative.reqmts] Status: NAD
  Submitter: Hans B os Opened: 2004-12-19  Last modified: 2006-12-27
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -9916,7 +10904,7 @@ last) and insert(first, last).
    
 
 
    
 
    499. Std. doesn't seem to require stable_sort() to be stable!
    
-
    Section: 25.5.1.2 [stable.sort] Status: NAD Editorial
+
    Section: 25.4.1.2 [stable.sort] Status: NAD Editorial
  Submitter: Prateek Karandikar Opened: 2005-04-12  Last modified: 2008-03-13
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -11071,6 +12059,7 @@ in the WP.
 
    526. Is it undefined if a function in the standard changes in parameters?
    
 
    Section: 23.2.3 [sequence.reqmts] Status: NAD
  Submitter: Chris Jefferson Opened: 2005-09-14  Last modified: 2008-03-13
    
+
    View other active issues in [sequence.reqmts].
    
 
    View all other issues in [sequence.reqmts].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -11205,7 +12194,7 @@ doesn't give permission for it not to work.
    • 
 doesn't give permission for it not to work.
 
  • vector::insert(iter, iter, iter) is not required to work because
 23.2.3 [sequence.reqmts], p4 says so.
    • 
-
  • copy has to work, except where 25.4.1 [alg.copy] says
+
  • copy has to work, except where 25.3.1 [alg.copy] says
 it doesn't have to work.  While a language lawyer can tear this wording apart,
 it is felt that the wording is not prone to accidental interpretation.
    • 
 
  • The current working draft provide exceptions for the unordered associative
@@ -11388,13 +12377,117 @@ Alan provided the survey
 
 
 
    
-
    536. Container iterator constructor and explicit convertibility
    
-
    Section: 23.2 [container.requirements] Status: Dup
- Submitter: Joaquín M López Muńoz Opened: 2005-12-17  Last modified: 2007-04-18
    
-
    View other active issues in [container.requirements].
    
-
    View all other issues in [container.requirements].
    
-
    View all issues with Dup status.
    
-
    Duplicate of: 589
    
+
    532. Tuple comparison
    
+
    Section: 20.5.2.7 [tuple.rel], TR1 6.1.3.5 [tr.tuple.rel] Status: NAD Future
+ Submitter: David Abrahams Opened: 2005-11-29  Last modified: 2009-10-24
    
+
    View all other issues in [tuple.rel].
    
+
    View all issues with NAD Future status.
    
+
    Duplicate of: 348
    
+
    Discussion:
    
+
    
+Where possible, tuple comparison operators <,<=,=>, and > ought to be
+defined in terms of std::less rather than operator<, in order to
+support comparison of tuples of pointers.  
+
    
+
+
    [
+2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+
    
+If we solve this for tuple we would have to solve it for pair
+algorithms, etc.  It is too late to do that at this time.  Move to NAD Future.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+change 6.1.3.5/5 from:
+
    
+
+
    
+  Returns: The result of a lexicographical comparison between t and
+  u. The result is defined as: (bool)(get<0>(t) < get<0>(u)) ||
+  (!(bool)(get<0>(u) < get<0>(t)) && ttail < utail), where rtail for
+  some tuple r is a tuple containing all but the first element of
+  r. For any two zero-length tuples e and f, e < f returns false.
+
    
+
+
    
+to:
+
    
+
+
    
+
    
+  Returns: The result of a lexicographical comparison between t and
+  u. For any two zero-length tuples e and f, e < f returns false.
+  Otherwise, the result is defined as: cmp( get<0>(t), get<0>(u)) ||
+  (!cmp(get<0>(u), get<0>(t)) && ttail < utail), where rtail for some
+  tuple r is a tuple containing all but the first element of r, and
+  cmp(x,y) is an unspecified function template defined as follows.
+
    
+
    
+  Where T is the type of x and U is the type of y:
+
    
+
+
    
+     if T and U are pointer types and T is convertible to U, returns
+     less<U>()(x,y)
+
    
+
+
    
+     otherwise, if T and U are pointer types, returns less<T>()(x,y)
+
    
+
+
    
+     otherwise, returns (bool)(x < y)
+
    
+
    
+
+
    [
+Berlin: This issue is much bigger than just tuple (pair, containers,
+algorithms). Dietmar will survey and work up proposed wording.
+]
    
+
+
+
+
+
    Rationale:
    
+
    
+Recommend NAD.  This will be fixed with the next revision of concepts.
+
    
+
+
    [
+San Francisco:
+]
    
+
+
+
    
+Solved by
+N2770.
+
    
+
+
+
+
+
+
    
+
    536. Container iterator constructor and explicit convertibility
    
+
    Section: 23.2 [container.requirements] Status: Dup
+ Submitter: Joaquín M López Muńoz Opened: 2005-12-17  Last modified: 2007-04-18
    
+
    View other active issues in [container.requirements].
    
+
    View all other issues in [container.requirements].
    
+
    View all issues with Dup status.
    
+
    Duplicate of: 589
    
 
    Discussion:
    
 
    
 The iterator constructor X(i,j) for containers as defined in 23.1.1 and
@@ -11463,7 +12556,6 @@ Berlin: Some support, not universal, for respecting the explicit qualifier.
 
    544. minor NULL problems in C.2
    
 
    Section: C.2 [diff.library] Status: NAD Editorial
  Submitter: Martin Sebor Opened: 2005-11-25  Last modified: 2007-04-24
    
-
    View other active issues in [diff.library].
    
 
    View all other issues in [diff.library].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -11884,7 +12976,7 @@ may not be unique if intmax_t==_longlong.
 
 
    
 
    558. lib.input.iterators Defect
    
-
    Section: 24.2.2 [input.iterators] Status: NAD Editorial
+
    Section: 24.2.1 [input.iterators] Status: NAD Editorial
  Submitter: David Abrahams Opened: 2006-02-09  Last modified: 2007-04-24
    
 
    View all other issues in [input.iterators].
    
 
    View all issues with NAD Editorial status.
    
@@ -11932,9 +13024,8 @@ Portland: Editorial.
 
 
    
 
    560. User-defined allocators without default constructor
    
-
    Section: X [allocator.requirements] Status: NAD
+
    Section: 20.2.2 [allocator.requirements] Status: NAD
  Submitter: Sergey P. Derevyago Opened: 2006-02-17  Last modified: 2007-04-18
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -12440,9 +13531,186 @@ uses depend on the iterator being returned.
 
 
 
+
    
+
    580. unused allocator members
    
+
    Section: 23.2.1 [container.requirements.general] Status: NAD Editorial
+ Submitter: Martin Sebor Opened: 2006-06-14  Last modified: 2009-10-26
    
+
    View other active issues in [container.requirements.general].
    
+
    View all other issues in [container.requirements.general].
    
+
    View all issues with NAD Editorial status.
    
+
    Duplicate of: 479
    
+
    Discussion:
    
+        
    
+
+C++ Standard Library  templates that take an allocator  as an argument
+are    required    to    call    the    allocate()    and
+deallocate()  members of the  allocator object  to obtain
+storage.  However, they do not appear to be required to call any other
+allocator      members      such     as      construct(),
+destroy(),           address(),          and
+max_size().  This makes these allocator members less than
+useful in portable programs.
+
+        
    
+        
    
+
+It's unclear to me whether the absence of the requirement to use these
+allocator  members  is  an  unintentional  omission  or  a  deliberate
+choice. However,  since the functions exist in  the standard allocator
+and  since  they are  required  to  be  provided by  any  user-defined
+allocator I  believe the standard  ought to be clarified  to explictly
+specify  whether programs  should or  should not  be able  to  rely on
+standard containers calling the functions.
+
+        
    
+        
    
+
+I  propose  that all  containers  be required  to  make  use of  these
+functions.
+
+        
    
+
    [
+Batavia:  We support this resolution.  Martin to provide wording.
+]
    
+
+
    [
+pre-Oxford:  Martin provided wording.
+]
    
+
+
+
    [
+2009-04-28 Pablo adds:
+]
    
+
+
+
    
+N2554
+(scoped allocators),
+N2768
+(allocator concepts), and
+N2810
+(allocator defects), address all of these points EXCEPT max_size().
+So, I would add a note to that affect and re-class the defect as belonging
+to section 23.2.1 [container.requirements.general].
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+The comment in the description of this issue that this "would be"
+rendered editorial by the adoption of N2257 is confusing. It appears
+that N2257 was never adopted.
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Addressed by
+N2982.
+
    
+
+
+
+    
    Proposed resolution:
    
+       
    
+
+Specifically, I propose to change 23.2 [container.requirements],
+p9 as follows:
+
+       
    
+           
    
+
    
+-9- Copy constructors  for all container types defined  in this clause
+that   are  parametrized  on   Allocator  copy
+anthe  allocator argument from  their respective
+first parameters.
+
+All other  constructors for  these container types  take an
+const  Allocator&  argument  (20.1.6),  an
+allocator whose value_type is the same as the container's
+value_type.
+
+A copy of this  argument isshall be used for any
+memory  allocation  and  deallocation performed,
+by these  constructors and by all  member functions, during
+the  lifetime  of each  container  object.   Allocation shall  be
+performed  "as  if"  by  calling  the  allocate()  member
+function on  a copy  of the allocator  object of the  appropriate type
+New  Footnote),   and  deallocation  "as   if"  by  calling
+deallocate() on  a copy of  the same allocator  object of
+the corresponding type.
+
+A  copy of  this argument  shall also  be used  to  construct and
+destroy objects whose lifetime  is managed by the container, including
+but not  limited to those of  the container's value_type,
+and  to  obtain  their  address.   All  objects  residing  in  storage
+allocated by a  container's allocator shall be constructed  "as if" by
+calling the construct() member  function on a copy of the
+allocator object of  the appropriate type.  The same  objects shall be
+destroyed "as if"  by calling destroy() on a  copy of the
+same allocator object  of the same type.  The  address of such objects
+shall be obtained "as if" by calling the address() member
+function  on  a  copy  of  the allocator  object  of  the  appropriate
+type.
+
+Finally, a copy  of this argument shall be  used by its container
+object to determine  the maximum number of objects  of the container's
+value_type the container may  store at the same time. The
+container  member function max_size() obtains  this number
+from      the      value      returned      by     a      call      to
+get_allocator().max_size().
+
+In   all  container   types  defined   in  this   clause that  are
+parametrized     on    Allocator,     the    member
+get_allocator()     returns     a     copy     of     the
+Allocator     object     used     to    construct     the
+container.258)
+
    
+
    
+New Footnote: This type  may be different from Allocator:
+it     may    be     derived    from     Allocator    via
+Allocator::rebind<U>::other   for  the  appropriate
+type U.
+
    
+           
    
+       
    
+
+The proposed wording seems cumbersome but I couldn't think of a better
+way   to  describe   the   requirement  that   containers  use   their
+Allocator  to manage  only objects  (regardless  of their
+type)  that  persist  over  their  lifetimes  and  not,  for  example,
+temporaries  created on the  stack. That  is, containers  shouldn't be
+required  to  call  Allocator::construct(Allocator::allocate(1),
+elem)  just to  construct a  temporary copy  of an  element, or
+Allocator::destroy(Allocator::address(temp),     1)    to
+destroy temporaries.
+
+       
    
+
+
+
    [
+Howard: This same paragraph will need some work to accommodate 431.
+]
    
+
+
+
    [
+post Oxford:  This would be rendered NAD Editorial by acceptance of
+N2257.
+]
    
+
+
+
+
+
 
    
 
    582. specialized algorithms and volatile storage
    
-
    Section: 20.8.8.2 [uninitialized.copy] Status: NAD
+
    Section: 20.8.13.2 [uninitialized.copy] Status: NAD
  Submitter: Martin Sebor Opened: 2006-06-14  Last modified: 2009-07-15
    
 
    View all other issues in [uninitialized.copy].
    
 
    View all issues with NAD status.
    
@@ -12494,7 +13762,7 @@ possible editorial change would be to put my previous sentence into a
 non-normative note.
 
    
 
    
-Note that the three sections starting with 20.8.8.2 [uninitialized.copy] do not
+Note that the three sections starting with 20.8.13.2 [uninitialized.copy] do not
 yet have concepts.  Here's a first crack at the first one:
 
    
 
    template <InputIterator InIter, OutputIterator OutIter>
@@ -12863,7 +14131,7 @@ Proposed Disposition: Open
 
 
    
 
    587. iststream ctor missing description
    
-
    Section: D.7.2.1 [depr.istrstream.cons] Status: NAD Editorial
+
    Section: D.8.2.1 [depr.istrstream.cons] Status: NAD Editorial
  Submitter: Martin Sebor Opened: 2006-06-22  Last modified: 2007-05-11
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -12895,138 +14163,343 @@ post Oxford: Noted that it is already fixed in
 
 
 
    
-
    590. Type traits implementation latitude should be removed for C++0x
    
-
    Section: 20.6 [meta], TR1 4.9 [tr.meta.req] Status: NAD Editorial
- Submitter: Beman Dawes Opened: 2006-08-10  Last modified: 2007-05-11
    
-
    View other active issues in [meta].
    
-
    View all other issues in [meta].
    
-
    View all issues with NAD Editorial status.
    
+
    588. requirements on zero sized tr1::arrays and other details
    
+
    Section: 23.3.1 [array] Status: NAD
+ Submitter: Gennaro Prota Opened: 2006-07-18  Last modified: 2009-10-20
    
+
    View all other issues in [array].
    
+
    View all issues with NAD status.
    
 
    Discussion:
    
 
    
-20.4.9 [lib.meta.req], Implementation requirements, provides latitude for type
-traits implementers that is not needed in C++0x. It includes the wording:
+The wording used for section 23.2.1 [lib.array] seems to be subtly
+ambiguous about zero sized arrays (N==0). Specifically:
 
    
-
-
    
-[Note: the latitude granted to implementers in this clause is temporary,
-and is expected to be removed in future revisions of this document. -- end note]
-
    
-
 
    
-Note:
-N2157: Minor Modifications to the type traits Wording
-also has the intent of removing this wording from the WP.
+* "An instance of array<T, N> stores N elements of type T, so that
+[...]"
 
    
-
-
-
-
    Proposed resolution:
    
 
    
-Remove 20.4.9 [lib.meta.req] in its entirety from the WP.
+Does this imply that a zero sized array object stores 0 elements, i.e.
+that it cannot store any element of type T? The next point clarifies
+the rationale behind this question, basically how to implement begin()
+and end():
 
    
-
-
    [
-post-Oxford: Recommend NAD Editorial.  This resolution is now in the
-current working draft.
-]
    
-
-
-
-
-
-
-
-
    
-
    591. Misleading "built-in
    
-
    Section: 18.3.1.2 [numeric.limits.members] Status: NAD Editorial
- Submitter: whyglinux Opened: 2006-08-08  Last modified: 2007-07-02
    
-
    View all other issues in [numeric.limits.members].
    
-
    View all issues with NAD Editorial status.
    
-
    Discussion:
    
 
    
-18.2.1.2 numeric_limits members [lib.numeric.limits.members]
-Paragraph 7:
+* 23.2.1.5 [lib.array.zero], p2: "In the case that N == 0, begin() ==
+end() == unique value."
 
    
-
    
-"For built-in integer types, the number of non-sign bits in the
-representation."
-
    
-
 
    
-26.1 Numeric type requirements [lib.numeric.requirements]
-Footnote:
+What does "unique" mean in this context? Let's consider the following
+possible implementations, all relying on a partial specialization:
 
    
+
    a)
+    template< typename T >
+    class array< T, 0 > {
+    
+        ....
 
-
    
-"In other words, value types. These include built-in arithmetic types,
-pointers, the library class complex, and instantiations of valarray for
-value types."
-
    
+        iterator begin()
+        { return iterator( reinterpret_cast< T * >( this ) ); }
+        ....
 
+    };
+
    
 
    
-Integer types (which are bool, char, wchar_t, and the signed and
-unsigned integer types) and arithmetic types (which are integer and
-floating types) are all built-in types and thus there are no
-non-built-in (that is, user-defined) integer or arithmetic types. Since
-the redundant "built-in" in the above 2 sentences can mislead that
-there may be built-in or user-defined integer and arithmetic types
-(which is not correct), the "built-in" should be removed.
+This has been used in boost, probably intending that the return value
+had to be unique to the specific array object and that array couldn't
+store any T. Note that, besides relying on a reinterpret_cast, has
+(more than potential) alignment problems.
 
    
+
    b)
+    template< typename T >
+    class array< T, 0 > {
+    
+        T t;
 
+        iterator begin()
+        { return iterator( &t ); }
+        ....
 
-
    Proposed resolution:
    
+    };
+
    
 
    
-18.2.1.2 numeric_limits members [lib.numeric.limits.members]
-Paragraph 7:
+This provides a value which is unique to the object and to the type of
+the array, but requires storing a T. Also, it would allow the user to
+mistakenly provide an initializer list with one element.
 
    
-
    
-"For built-in integer types, the number of non-sign bits in the
-representation."
-
    
-
 
    
-26.1 Numeric type requirements [lib.numeric.requirements]
-Footnote:
+A slight variant could be returning *the* null pointer of type T
 
    
-
-
    
-"In other words, value types. These include built-in arithmetic types,
-pointers, the library class complex, and instantiations of valarray for
-value types."
-
    
-
-
-
    Rationale:
    
+
        return static_cast<T*>(0);
+
    
 
    
-Recommend NAD / Editorial.  The proposed resolution is accepted as editorial.
+In this case the value would be unique to the type array<T, 0> but not
+to the objects (all objects of type array<T, 0> with the same value
+for T would yield the same pointer value).
 
    
-
-
-
-
-
-
    
-
    592. Incorrect treatment of rdbuf()->close() return type
    
-
    Section: 27.9.1.9 [ifstream.members] Status: NAD Editorial
- Submitter: Christopher Kohlhoff Opened: 2006-08-17  Last modified: 2008-07-02
    
-
    View all other issues in [ifstream.members].
    
-
    View all issues with NAD Editorial status.
    
-
    Discussion:
    
 
    
-I just spotted a minor problem in 27.8.1.7
-[lib.ifstream.members] para 4 and also 27.8.1.13
-[lib.fstream.members] para 4. In both places it says:
+Furthermore this is inconsistent with what the standard requires from
+allocation functions (see library issue 9).
 
    
-
    
-
    void close();
-
    
 
    
-Effects: Calls rdbuf()->close() and, if that function returns false, ...
+c) same as above but with t being a static data member; again, the
+value would be unique to the type, not to the object.
 
    
-
    
 
    
-However, basic_filebuf::close() (27.8.1.2) returns a pointer to the
-filebuf on success, null on failure, so I think it is meant to
+d) to avoid storing a T *directly* while disallowing the possibility
+to use a one-element initializer list a non-aggregate nested class
+could be defined
+
    
+
        struct holder { holder() {} T t; } h;
+
    
+
    
+and then begin be defined as
+
    
+
     iterator begin() { return &h.t; }
+
    
+
    
+But then, it's arguable whether the array stores a T or not.
+Indirectly it does.
+
    
+
    
+-----------------------------------------------------
+
    
+
    
+Now, on different issues:
+
    
+
    
+* what's the effect of calling assign(T&) on a zero-sized array? There
+seems to be only mention of front() and back(), in 23.2.1 [lib.array]
+p4 (I would also suggest to move that bullet to section 23.2.1.5
+[lib.array.zero], for locality of reference)
+
    
+
    
+* (minor) the opening paragraph of 23.2.1 [lib.array] wording is a bit
+inconsistent with that of other sequences: that's not a problem in
+itself, but compare it for instance with "A vector is a kind of
+sequence that supports random access iterators"; though the intent is
+obvious one might argue that the wording used for arrays doesn't tell
+what an array is, and relies on the reader to infer that it is what
+the <array> header defines.
+
    
+
    
+* it would be desiderable to have a static const data member of type
+std::size_t, with value N, for usage as integral constant expression
+
    
+
    
+* section 23.1 [lib.container.requirements] seem not to consider
+fixed-size containers at all, as it says: "[containers] control
+allocation and deallocation of these objects [the contained objects]
+through constructors, destructors, *insert and erase* operations"
+
    
+
    
+* max_size() isn't specified: the result is obvious but, technically,
+it relies on table 80: "size() of the largest possible container"
+which, again, doesn't seem to consider fixed size containers
+
    
+
+
    [
+2009-05-29 Daniel adds:
+]
    
+
+
+
    
+
      
+
    1. 
+
      
+star bullet 1 ("what's the effect of calling assign(T&) on a
+zero-sized array?[..]");
+
      
+
      
+assign has been renamed to fill and the semantic of fill is now
+defined in terms of
+the free algorithm fill_n, which is well-defined for this situation.
+
      
+
      2. 
+
    2. 
+
      
+star bullet 3 ("it would be desiderable to have a static const data
+member..."):
+
      
+
      
+It seems that tuple_size<array<T, N> >::value as of 23.3.1.7 [array.tuple] does
+provide this functionality now.
+
      
+
      3. 
+
    
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Alisdair to address by the next meeting, or declare NAD.
+
    
+
    
+Moved to Tentatively NAD.
+
    
+
    
+
+
    [
+2009 Santa Cruz:
+]
    
+
+
+
    
+Moved to NAD.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+
    
+
+
+
    [
+Kona (2007): requirements on zero sized tr1::arrays and other details
+Issue 617: std::array is a sequence that doesn't satisfy the sequence
+requirements? Alisdair will prepare a paper. Proposed Disposition: Open
+]
    
+
+
+
+
+
+
    
+
    590. Type traits implementation latitude should be removed for C++0x
    
+
    Section: 20.6 [meta], TR1 4.9 [tr.meta.req] Status: NAD Editorial
+ Submitter: Beman Dawes Opened: 2006-08-10  Last modified: 2007-05-11
    
+
    View all other issues in [meta].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    
+20.4.9 [lib.meta.req], Implementation requirements, provides latitude for type
+traits implementers that is not needed in C++0x. It includes the wording:
+
    
+
+
    
+[Note: the latitude granted to implementers in this clause is temporary,
+and is expected to be removed in future revisions of this document. -- end note]
+
    
+
+
    
+Note:
+N2157: Minor Modifications to the type traits Wording
+also has the intent of removing this wording from the WP.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Remove 20.4.9 [lib.meta.req] in its entirety from the WP.
+
    
+
+
    [
+post-Oxford: Recommend NAD Editorial.  This resolution is now in the
+current working draft.
+]
    
+
+
+
+
+
+
+
+
    
+
    591. Misleading "built-in
    
+
    Section: 18.3.1.2 [numeric.limits.members] Status: NAD Editorial
+ Submitter: whyglinux Opened: 2006-08-08  Last modified: 2007-07-02
    
+
    View all other issues in [numeric.limits.members].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    
+18.2.1.2 numeric_limits members [lib.numeric.limits.members]
+Paragraph 7:
+
    
+
    
+"For built-in integer types, the number of non-sign bits in the
+representation."
+
    
+
+
    
+26.1 Numeric type requirements [lib.numeric.requirements]
+Footnote:
+
    
+
+
    
+"In other words, value types. These include built-in arithmetic types,
+pointers, the library class complex, and instantiations of valarray for
+value types."
+
    
+
+
    
+Integer types (which are bool, char, wchar_t, and the signed and
+unsigned integer types) and arithmetic types (which are integer and
+floating types) are all built-in types and thus there are no
+non-built-in (that is, user-defined) integer or arithmetic types. Since
+the redundant "built-in" in the above 2 sentences can mislead that
+there may be built-in or user-defined integer and arithmetic types
+(which is not correct), the "built-in" should be removed.
+
    
+
+
+
    Proposed resolution:
    
+
    
+18.2.1.2 numeric_limits members [lib.numeric.limits.members]
+Paragraph 7:
+
    
+
    
+"For built-in integer types, the number of non-sign bits in the
+representation."
+
    
+
+
    
+26.1 Numeric type requirements [lib.numeric.requirements]
+Footnote:
+
    
+
+
    
+"In other words, value types. These include built-in arithmetic types,
+pointers, the library class complex, and instantiations of valarray for
+value types."
+
    
+
+
+
    Rationale:
    
+
    
+Recommend NAD / Editorial.  The proposed resolution is accepted as editorial.
+
    
+
+
+
+
+
+
    
+
    592. Incorrect treatment of rdbuf()->close() return type
    
+
    Section: 27.9.1.9 [ifstream.members] Status: NAD Editorial
+ Submitter: Christopher Kohlhoff Opened: 2006-08-17  Last modified: 2008-07-02
    
+
    View all other issues in [ifstream.members].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    
+I just spotted a minor problem in 27.8.1.7
+[lib.ifstream.members] para 4 and also 27.8.1.13
+[lib.fstream.members] para 4. In both places it says:
+
    
+
    
+
    void close();
+
    
+
    
+Effects: Calls rdbuf()->close() and, if that function returns false, ...
+
    
+
    
+
    
+However, basic_filebuf::close() (27.8.1.2) returns a pointer to the
+filebuf on success, null on failure, so I think it is meant to
 say "if that function returns a null pointer". Oddly, it is
 correct for basic_ofstream.
 
    
@@ -13365,39 +14838,168 @@ Recommend NAD, editorial.  Send to Pete.
 
 
 
    
-
    626. new Remark clauses not documented
    
-
    Section: 17.5.1.4 [structure.specifications] Status: NAD Editorial
- Submitter: Martin Sebor Opened: 2007-01-20  Last modified: 2008-02-25
    
-
    View all other issues in [structure.specifications].
    
-
    View all issues with NAD Editorial status.
    
+
    617. std::array is a sequence that doesn't satisfy the sequence requirements?
    
+
    Section: 23.3.1 [array] Status: NAD
+ Submitter: Bo Persson Opened: 2006-12-30  Last modified: 2009-10-20
    
+
    View all other issues in [array].
    
+
    View all issues with NAD status.
    
 
    Discussion:
    
-        
    
-
-The Remark clauses newly  introduced into the Working Paper 
-(N2134)
-are  not mentioned  in  17.5.1.4 [structure.specifications] where  we list  the
-meaning  of Effects, Requires,  and other  clauses (with
-the exception  of Notes which are documented  as informative in
-17.5.1.2 [structure.summary], p2, and which they replace in many cases).
-
-        
    
-        
    
-
-Propose add a bullet for Remarks along with a brief description.
+
    
+The <array> header is given under 23.3 [sequences].
+23.3.1 [array]/paragraph 3 says:
+
    
+
    
+"Unless otherwise specified, all array operations are as described in
+23.2 [container.requirements]".
+
    
+
    
+However, array isn't mentioned at all in section 23.2 [container.requirements].
+In particular, Table 82 "Sequence requirements" lists several operations (insert, erase, clear) 
+that std::array does not have in 23.3.1 [array].
+
    
+
    
+Also, Table 83 "Optional sequence operations" lists several operations that 
+std::array does have, but array isn't mentioned.
+
    
 
-        
    
 
    [
-Batavia:  Alan and Pete to work.
+2009-07 Frankfurt
 ]
    
 
 
+
    
+
    
+The real issue seems to be different than what is described here.
+Non-normative text says that std::array is a sequence container, but
+there is disagreement about what that really means. There are two
+possible interpretations:
+
    
+
      
+
    1. 
+a sequence container is one that satisfies all sequence container requirements
+
      2. 
+
    2. 
+a sequence container is one that satisfies some of the sequence
+container requirements. Any operation that the container supports is
+specified by one or more sequence container requirements, unless that
+operation is specifically singled out and defined alongside the
+description of the container itself.
+
      3. 
+
    
+
    
+Move to Tentatively NAD.
+
    
+
    
+
 
    [
-Bellevue: Already resolved in current working paper.
+2009-07-15 Loďc Joly adds:
 ]
    
 
 
-
-
    Proposed resolution:
    
+
    
+
    
+The section 23.2.3 [sequence.reqmts]/1 states that array is a sequence. 23.2.3 [sequence.reqmts]/3
+introduces table 83, named Sequence container requirements. This seems
+to me to be defining the requirements for all sequences. However, array
+does not follow all of this requirements (this can be read in the array
+specific section, for the standard is currently inconsistent).
+
    
+
+
    
+Proposed resolution 1 (minimal change): 
+
    
+
    
+
    
+Say that array is a container, that in addition follows only some of the
+sequence requirements, as described in the array section:
+
    
+
+
    
+The library provides five three basic kinds of sequence containers: array,
+vector, 
+forward_list, list, and deque. In addition, array
+and forward_list follows some of the requirements 
+of sequences, as described in their respective sections.
+
    
+
+
    
+
+
    
+Proposed resolution 2 (most descriptive description, no full wording provided): 
+
    
+
    
+Introduce the notion of a Fixed Size Sequence, with it requirement table
+that would be a subset of the current Sequence container. array would be
+the only Fixed Size Sequence (but dynarray is in the queue for TR2).
+Sequence requirements would now be requirements in addition to Fixed
+Size Sequence requirements (it is currently in addition to container).
+
    
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Move to NAD Editorial
+
    
+
+
    [
+2009 Santa Cruz:
+]
    
+
+
+
    
+This will require a lot of reorganization. Editor doesn't think this is really
+an issue, since the description of array can be considered as overriding
+what's specified about sequences. Move to NAD.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+
    
+
+
+
+
+
+
    
+
    626. new Remark clauses not documented
    
+
    Section: 17.5.1.4 [structure.specifications] Status: NAD Editorial
+ Submitter: Martin Sebor Opened: 2007-01-20  Last modified: 2008-02-25
    
+
    View all other issues in [structure.specifications].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+        
    
+
+The Remark clauses newly  introduced into the Working Paper 
+(N2134)
+are  not mentioned  in  17.5.1.4 [structure.specifications] where  we list  the
+meaning  of Effects, Requires,  and other  clauses (with
+the exception  of Notes which are documented  as informative in
+17.5.1.2 [structure.summary], p2, and which they replace in many cases).
+
+        
    
+        
    
+
+Propose add a bullet for Remarks along with a brief description.
+
+        
    
+
    [
+Batavia:  Alan and Pete to work.
+]
    
+
+
+
    [
+Bellevue: Already resolved in current working paper.
+]
    
+
+
+
+
    Proposed resolution:
    
 
    
 
    
 
@@ -13539,12 +15141,12 @@ Fixed by paper N2923.
 
 
    
 
    633. Return clause mentions undefined "type()"
    
-
    Section: 20.7.16.2.5 [func.wrap.func.targ] Status: NAD Editorial
+
    Section: 20.7.15.2.5 [func.wrap.func.targ] Status: NAD Editorial
  Submitter: Daniel Krügler Opened: 2007-02-03  Last modified: 2007-07-02
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
 
    
-20.7.16.2.5 [func.wrap.func.targ], p4 says:
+20.7.15.2.5 [func.wrap.func.targ], p4 says:
 
    
 
    
 Returns: If type() == typeid(T), a pointer to the stored
@@ -13560,7 +15162,7 @@ function type() in class template function nor in the global or
 
  • 
 Assuming that type should have been target_type(),
 this description would lead to false results, if T = cv
-void due to returns clause 20.7.16.2.5 [func.wrap.func.targ], p1.
+void due to returns clause 20.7.15.2.5 [func.wrap.func.targ], p1.
 
    • 
 
 
@@ -13568,7 +15170,7 @@ void due to returns clause 20.7.16.2.5 [func.wrap.func.targ], p1.
 
 
    Proposed resolution:
    
 
    
-Change 20.7.16.2.5 [func.wrap.func.targ], p4:
+Change 20.7.15.2.5 [func.wrap.func.targ], p4:
 
    
 
 
    
@@ -13587,6 +15189,132 @@ Pete: Agreed. It's editorial, so I'll fix it.
 
 
 
+
    
+
    635. domain of allocator::address
    
+
    Section: 20.2.2 [allocator.requirements] Status: NAD Editorial
+ Submitter: Howard Hinnant Opened: 2007-02-08  Last modified: 2009-10-26
    
+
    View all other issues in [allocator.requirements].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    
+The table of allocator requirements in 20.2.2 [allocator.requirements] describes
+allocator::address as:
+
    
+
    a.address(r)
+a.address(s)
+
    
+
    
+where r and s are described as:
+
    
+
    
+a value of type X::reference obtained by the expression *p. 
+
    
+
+
    
+and p is 
+
    
+
+
    
+a value of type X::pointer, obtained by calling a1.allocate, 
+where a1 == a
+
    
+
+
    
+This all implies that to get the address of some value of type T that
+value must have been allocated by this allocator or a copy of it.
+
    
+
+
    
+However sometimes container code needs to compare the address of an external value of
+type T with an internal value.  For example list::remove(const T& t)
+may want to compare the address of the external value t with that of a value
+stored within the list.  Similarly vector or deque insert may
+want to make similar comparisons (to check for self-referencing calls).
+
    
+
+
    
+Mandating that allocator::address can only be called for values which the
+allocator allocated seems overly restrictive.
+
    
+
+
    [
+post San Francisco:
+]
    
+
+
+
    
+Pablo recommends NAD Editorial, solved by
+N2768.
+
    
+
+
    [
+2009-04-28 Pablo adds:
+]
    
+
+
+
    
+Tentatively-ready NAD Editorial as fixed by
+N2768.
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+Fixed by N2768.
+
    
+
+
    [
+2009-07-28 Reopened by Alisdair.  No longer solved by concepts.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Addressed by
+N2982.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change 20.2.2 [allocator.requirements]:
+
    
+
+
    
+
    
+r : a value of type X::reference obtained by the expression *p.
+
    
+
    
+s : a value of type X::const_reference obtained by the 
+expression *q or by conversion from a value r.
+
    
+
    
+
+
    [
+post Oxford:  This would be rendered NAD Editorial by acceptance of
+N2257.
+]
    
+
+
+
    [
+Kona (2007):  This issue is section 8 of N2387.  There was some discussion of it but
+no resolution to this issue was recorded.  Moved to Open.
+]
    
+
+
+
+
+
+
+
 
    
 
    636. 26.5.2.3 valarray::operator[]
    
 
    Section: 26.6.2.3 [valarray.access] Status: NAD Editorial
@@ -13903,13 +15631,13 @@ In 27.9.1.13 [ofstream.members], remove footnote:
 
 
    
 
    644. Possible typos in 'function' description
    
-
    Section: 20.7.16.2 [func.wrap.func] Status: NAD
+
    Section: 20.7.15.2 [func.wrap.func] Status: NAD
  Submitter: Bo Persson Opened: 2007-02-25  Last modified: 2009-07-13
    
 
    View all other issues in [func.wrap.func].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
    
-20.7.16.2 [func.wrap.func]
+20.7.15.2 [func.wrap.func]
 
    
 
    
 The note in paragraph 2 refers to 'undefined void operators', while the
@@ -13935,7 +15663,7 @@ type of these deleted functions to be?
 
    
 
    
 I suggest harmonizing this issue with similar classes. E.g. in
-20.8.10.3 [util.smartptr.weak] bool return values for
+20.8.15.3 [util.smartptr.weak] bool return values for
 
    
 
    template <class Y> bool operator<(weak_ptr<Y> const&) const = delete;
 template <class Y> bool operator<=(weak_ptr<Y> const&) const = delete;
@@ -13973,19 +15701,19 @@ Move to NAD.
 
 
    Proposed resolution:
    
 
    
-Change 20.7.16.2 [func.wrap.func]
+Change 20.7.15.2 [func.wrap.func]
 
    
 
 
    ...
 private:
-   // 20.7.16.2 [func.wrap.func], undefined operators:
+   // 20.7.15.2 [func.wrap.func], undefined operators:
    template<class Function2> bool void operator==(const function<Function2>&);
    template<class Function2> bool void operator!=(const function<Function2>&);
 };
 
    
 
 
    
-Change 20.7.16.2 [func.wrap.func]
+Change 20.7.15.2 [func.wrap.func]
 
    
 
 
    template<class Function2> bool void operator==(const function<Function2>&);
@@ -14555,7 +16283,7 @@ void operator!=(const function<Function1>&, const function<Function
 
    
 which are nowhere described. I assume that they are relicts before the
 corresponding two private and undefined member templates in the function
-template (see 20.7.16.2 [func.wrap.func] and  [func.wrap.func.undef]) have been introduced. The original free
+template (see 20.7.15.2 [func.wrap.func] and  [func.wrap.func.undef]) have been introduced. The original free
 function templates should be removed, because using an undefined entity
 would lead to an ODR violation of the user.
 
    
@@ -14766,7 +16494,6 @@ identified, and big-O notation always involves constant factors.
 
    667. money_get's widened minus sign
    
 
    Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: NAD
  Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2009-07-13
    
-
    View other active issues in [locale.money.get.virtuals].
    
 
    View all other issues in [locale.money.get.virtuals].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -14842,124 +16569,333 @@ Move to NAD.
 
 
 
    
-
    669. Equivalent postive and negative signs in money_get
    
+
    668. money_get's empty minus sign
    
 
    Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: NAD
- Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2009-07-13
    
-
    View other active issues in [locale.money.get.virtuals].
    
+ Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2009-10-21
    
 
    View all other issues in [locale.money.get.virtuals].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
    
-22.4.6.1.2 [locale.money.get.virtuals], para 3 sentence 4 says:
+22.4.6.1.2 [locale.money.get.virtuals], para 3 says:
 
    
 
 
    
-If the first character of pos is equal to the first character of neg, 
-or if both strings are empty, the result is given a positive sign.
+If pos or neg is empty, the sign component is
+optional, and if no sign is detected, the result is given the sign
+that corresponds to the source of the empty string.
 
    
 
 
    
-One interpretation is that an input sequence must match either the
-positive pattern or the negative pattern, and then in either event it
-is interpreted as positive.  The following objections has been raised:
+The following objection has been raised:
 
    
 
 
    
-The input can successfully match only a positive sign, so the negative
-pattern is an unsuccessful match.
+A negative_sign of "" means "there is no
+way to write a negative sign" not "any null sequence is a negative
+sign, so it's always there when you look for it".
 
    
 
 
    
-[Plum ref _222612Y34, 222612Y51b]
+[Plum ref _222612Y32]
 
    
 
 
    [
-Bill to provide proposed wording and interpretation of existing wording.
+Kona (2007): Bill to provide proposed wording and interpretation of existing wording.
 ]
    
 
 
-
    [
-2009-05-17 See Howard's comments in related issue 668.
-]
    
-
+
    
+Related to 669.
+
    
 
 
    [
-Batavia (2009-05):
+2009-05-17 Howard adds:
 ]
    
 
+
 
    
 
    
-This discussion applies equally to issue 668 (q.v.).
-Howard has added examples there,
-and recommends either NAD or a resolution that adds his (or similar) examples
-to the Working Paper.
-
    
-
    
-We recommend moving to NAD.
-Anyone who feels strongly about adding the examples
-is invited to submit corresponding wording.
-We further recommend issue 668 be handled identically.
+I disagree that a negative_sign of "" means "there is no
+way to
+write a negative sign". The meaning requires the sentences of
+22.4.6.1.2 [locale.money.get.virtuals] p3 following that quoted above
+to be
+taken into account:
 
    
-
    
 
+
    
+-3- ... If pos or neg is empty, the sign component is
+optional, and if no sign is detected, the result is given the sign that
+corresponds to the source of the empty string. Otherwise, the character
+in the indicated position must match the first character of pos
+or neg, and the result is given the corresponding sign. If the
+first character of pos is equal to the first character of
+neg, or if both strings are empty, the result is given a
+positive sign.
+
    
 
-
    Proposed resolution:
    
 
    
+So a negative_sign of "" means "there is no way to write a
+negative sign" only when positive_sign is also "".  However
+when negative_sign is "" and postive_sign.size() >
+0, then one writes a negative value by not writing the
+postive_sign in the position indicated by
+money_base::sign.
+For example:
 
    
 
+
    pattern = {symbol, sign, value, none}
+positive_sign = "+"
+negative_sign = ""
+$123   // a negative value, using optional sign
+$+123  // a positive value
+$-123  // a parse error
+
    
 
+
    
+And:
+
    
 
+
    pattern = {symbol, sign, value, none}
+positive_sign = ""
+negative_sign = ""
+$123   // a positive value, no sign possible
+$+123  // a parse error
+$-123  // a parse error
+
    
 
 
-
    
-
    670. money_base::pattern and space
    
-
    Section: 22.4.6.3 [locale.moneypunct] Status: Dup
- Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2008-09-22
    
-
    View all issues with Dup status.
    
-
    Duplicate of: 836
    
-
    Discussion:
    
 
    
-22.4.6.3 [locale.moneypunct], para 2 says:
+And (regarding 669):
 
    
 
-
    
-The value space indicates that at least one space is required at 
-that position.
-
    
+
    pattern = {symbol, sign, value, none}
+positive_sign = "-"
+negative_sign = "-"
+$123   // a parse error, sign is mandatory
+$+123  // a parse error
+$-123  // a positive value
+
    
+
 
 
    
-The following objection has been raised:
+The text seems both unambiguous and clear to me.  I recommend NAD for
+both this issue and 669.  However I would have no
+objection to adding examples such as those above.
 
    
+
    
 
-
    
-Whitespace is optional when matching space. (See 22.4.6.1.2 [locale.money.get.virtuals], para 2.)
-
    
+
    [
+Batavia (2009-05):
+]
    
 
+
    
 
    
-[Plum ref _22263Y22]
+This discussion applies equally to issue 669 (q.v.).
+Howard has added examples above,
+and recommends either NAD or a resolution that adds his (or similar) examples
+to the Working Paper.
+
    
+
    
+Alan would like to rewrite paragraph 3.
+
    
+
    
+We recommend moving to NAD.
+Anyone who feels strongly about adding the examples
+is invited to submit corresponding wording.
+We further recommend issue 669 be handled identically.
 
    
+
    
 
 
    [
-Kona (2007): Bill to provide proposed wording. We agree that C++03 is
-ambiguous, and that we want C++0X to say "space" means 0 or more
-whitespace characters on input.
+2009-07-14 Alan reopens with improved wording.
 ]
    
 
 
+
    [
+2009-07 Frankfurt
+]
    
 
 
-
    Proposed resolution:
    
+
    
+No consensus for closing as NAD.  Leave in Review.
+
    
 
+
    [
+2009-10 Santa Cruz:
+]
    
 
 
+
    
+NAD.  Agreed that the original assessment as NAD was correct.
+
    
 
 
-
    
-
    683. regex_token_iterator summary error
    
-
    Section: 28.12.2 [re.tokiter] Status: NAD Editorial
- Submitter: Eric Niebler Opened: 2007-06-02  Last modified: 2009-03-09
    
-
    View all other issues in [re.tokiter].
    
-
    View all issues with NAD Editorial status.
    
+
+
    Proposed resolution:
    
+
    
+Change 22.4.6.1.2 [locale.money.get.virtuals] p3:
+
    
+
+
    
+-3- 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 the string are required after all the other format components.
+[Example: If showbase is off, then for a neg
+value of "()" and a currency symbol of "L", in "(100 L)" the "L" is
+consumed; but if neg is "-", the "L" in "-100 L" is not
+consumed. -- end example] If pos or neg is
+empty, the sign component is optional, and if no sign is detected, the
+result is given the sign that corresponds to the source of the empty
+string. Otherwise, the character in the indicated position must match
+the first character of pos or neg, and the result is
+given the corresponding sign. If the first character of pos is
+equal to the first character of neg, or if both strings are
+empty, the result is given a positive sign.
+
+The sign pattern strings pos and neg are returned by
+mp.positive_sign() and mp.negative_sign() respectively. A sign pattern
+is matched if its first character is recognized in s in the position
+indicated by sign in the format pattern, or if the pattern is empty and
+there is no sign recognized in s. A match is required to occur. If both
+patterns are matched, the result is given a positive sign, otherwise the
+result is given the sign corresponding to the matched pattern. 
+If the pattern contains more than one character, the characters after the first 
+must be matched in s after all other format components. 
+If any sign
+characters are matched, s is consumed up to and including those characters.
+[Example: If showbase is off, then for a neg
+value of "()" and a currency symbol of "L", in
+"(100 L)" the entire string is consumed; but for a neg
+value of "-", in "-100 L", the string is consumed
+through the second "0" (the space and "L" are not consumed). — end
+example] 
+
    
+
+
+
+
+
+
    
+
    669. Equivalent postive and negative signs in money_get
    
+
    Section: 22.4.6.1.2 [locale.money.get.virtuals] Status: NAD
+ Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2009-07-13
    
+
    View all other issues in [locale.money.get.virtuals].
    
+
    View all issues with NAD status.
    
+
    Discussion:
    
+
    
+22.4.6.1.2 [locale.money.get.virtuals], para 3 sentence 4 says:
+
    
+
+
    
+If the first character of pos is equal to the first character of neg, 
+or if both strings are empty, the result is given a positive sign.
+
    
+
+
    
+One interpretation is that an input sequence must match either the
+positive pattern or the negative pattern, and then in either event it
+is interpreted as positive.  The following objections has been raised:
+
    
+
+
    
+The input can successfully match only a positive sign, so the negative
+pattern is an unsuccessful match.
+
    
+
+
    
+[Plum ref _222612Y34, 222612Y51b]
+
    
+
+
    [
+Bill to provide proposed wording and interpretation of existing wording.
+]
    
+
+
+
    [
+2009-05-17 See Howard's comments in related issue 668.
+]
    
+
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+
    
+This discussion applies equally to issue 668 (q.v.).
+Howard has added examples there,
+and recommends either NAD or a resolution that adds his (or similar) examples
+to the Working Paper.
+
    
+
    
+We recommend moving to NAD.
+Anyone who feels strongly about adding the examples
+is invited to submit corresponding wording.
+We further recommend issue 668 be handled identically.
+
    
+
    
+
+
+
    Proposed resolution:
    
+
    
+
    
+
+
+
+
+
+
    
+
    670. money_base::pattern and space
    
+
    Section: 22.4.6.3 [locale.moneypunct] Status: Dup
+ Submitter: Thomas Plum Opened: 2007-04-16  Last modified: 2008-09-22
    
+
    View all issues with Dup status.
    
+
    Duplicate of: 836
    
+
    Discussion:
    
+
    
+22.4.6.3 [locale.moneypunct], para 2 says:
+
    
+
+
    
+The value space indicates that at least one space is required at 
+that position.
+
    
+
+
    
+The following objection has been raised:
+
    
+
+
    
+Whitespace is optional when matching space. (See 22.4.6.1.2 [locale.money.get.virtuals], para 2.)
+
    
+
+
    
+[Plum ref _22263Y22]
+
    
+
+
    [
+Kona (2007): Bill to provide proposed wording. We agree that C++03 is
+ambiguous, and that we want C++0X to say "space" means 0 or more
+whitespace characters on input.
+]
    
+
+
+
+
+
    Proposed resolution:
    
+
+
+
+
+
+
    
+
    683. regex_token_iterator summary error
    
+
    Section: 28.12.2 [re.tokiter] Status: NAD Editorial
+ Submitter: Eric Niebler Opened: 2007-06-02  Last modified: 2009-03-09
    
+
    View all other issues in [re.tokiter].
    
+
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
 
    
 28.12.2 [re.tokiter], p3 says:
@@ -15106,13 +17042,13 @@ Bellevue:  Proposed wording now in WP.
 
 
    
 
    686. Unique_ptr and shared_ptr fail to specify non-convertibility to int for unspecified-bool-type
    
-
    Section: 20.8.9.2.4 [unique.ptr.single.observers], 20.8.10.2.5 [util.smartptr.shared.obs] Status: NAD
+
    Section: 20.8.14.2.4 [unique.ptr.single.observers], 20.8.15.2.5 [util.smartptr.shared.obs] Status: NAD
  Submitter: Beman Dawes Opened: 2007-06-14  Last modified: 2008-02-27
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
 
    
 The standard library uses the operator unspecified-bool-type() const idiom in
-five places. In three of those places (20.7.16.2.3 [func.wrap.func.cap], function capacity 
+five places. In three of those places (20.7.15.2.3 [func.wrap.func.cap], function capacity 
 for example) the returned value is constrained to disallow
 unintended conversions to int. The standardese is
 
    
@@ -15140,8 +17076,8 @@ makes it irrelevant.
 
    
 To the Returns paragraph for operator unspecified-bool-type()
 const
-of 20.8.9.2.4 [unique.ptr.single.observers] paragraph 11 and
-20.8.10.2.5 [util.smartptr.shared.obs] paragraph 16, add the sentence:
+of 20.8.14.2.4 [unique.ptr.single.observers] paragraph 11 and
+20.8.15.2.5 [util.smartptr.shared.obs] paragraph 16, add the sentence:
 
    
 
    
 The return type shall not be convertible to int.
@@ -15605,6 +17541,138 @@ different, a string abstraction in its own right.
 
 
 
+
    
+
    719. std::is_literal type traits should be provided
    
+
    Section: 20.6 [meta] Status: NAD Editorial
+ Submitter: Daniel Krügler Opened: 2007-08-25  Last modified: 2009-10-26
    
+
    View all other issues in [meta].
    
+
    View all issues with NAD Editorial status.
    
+
    Duplicate of: 750
    
+
    Discussion:
    
+
    
+Since the inclusion of constexpr in the standard draft N2369 we have
+a new type category "literal", which is defined in 3.9 [basic.types]/p.11:
+
    
+
+
    
+
    
+-11- A type is a literal type if it is:
+
    
+
      
+
    • a scalar type; or
      • 
+
    • a class type (clause 9) with
      
+
        
+
      • a trivial copy constructor,
        • 
+
      • a trivial destructor,
        • 
+
      • at least one constexpr constructor other than the copy constructor,
        • 
+
      • no virtual base classes, and
        • 
+
      • all non-static data members and base classes of literal types; or
        • 
+
      
+
      • 
+
    • an array of literal type.
      • 
+
    
+
    
+
+
    
+I strongly suggest that the standard provides a type traits for
+literal types in 20.6.4.3 [meta.unary.prop] for several reasons:
+
    
+
+
      
+
    1. To keep the traits in sync with existing types.
      2. 
+
    2. I see many reasons for programmers to use this trait in template
+   code to provide optimized template definitions for these types,
+   see below.
      3. 
+
    3. A user-provided definition of this trait is practically impossible
+to write portably.
      4. 
+
    
+
+
    
+The special problem of reason (c) is that I don't see currently a
+way to portably test the condition for literal class types:
+
    
+
+
    
+
      
+
    • at least one constexpr constructor other than the copy constructor,
      • 
+
    
+
    
+
+
+
+
    [
+Alisdair is considering preparing a paper listing a number of missing
+type traits, and feels that it might be useful to handle them all
+together rather than piecemeal. This would affect issue 719 and 750.
+These two issues should move to OPEN pending AM paper on type traits.
+]
    
+
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Beman, Daniel, and Alisdair will work on a paper proposing new type traits.
+
    
+
+
    [
+Addressed in N2947.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Solved by
+N2984.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+In 20.6.2 [meta.type.synop] in the group "type properties",
+just below the line
+
    
+
+
    template <class T> struct is_pod;
+
    
+
+
    
+add a new one:
+
    
+
+
    template <class T> struct is_literal;
+
    
+
+
    
+In 20.6.4.3 [meta.unary.prop], table Type Property Predicates, just
+below the line for the is_pod property add a new line:
+
    
+
+
+
+
+
+
+
+
+
+
+
    TemplateConditionPreconditions
    template <class T> struct is_literal;T is a literal type (3.9)T shall be a complete type, an
+array of unknown bound, or
+(possibly cv-qualified) void.
    
+
+
+
+
+
+
 
    
 
    721. wstring_convert inconsistensies
    
 
    Section: 22.3.3.2.2 [conversions.string] Status: NAD
@@ -15674,6 +17742,7 @@ Move to NAD.
 
    725. Optional sequence container requirements column label
    
 
    Section: 23.2.3 [sequence.reqmts] Status: NAD Editorial
  Submitter: David Abrahams Opened: 2007-09-16  Last modified: 2008-09-22
    
+
    View other active issues in [sequence.reqmts].
    
 
    View all other issues in [sequence.reqmts].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -16458,7 +18527,7 @@ for the proposed resolution.
 
 
    
 
    741. Const-incorrect get_deleter function for shared_ptr
    
-
    Section: 20.8.10.2.11 [util.smartptr.getdeleter] Status: NAD
+
    Section: 20.8.15.2.11 [util.smartptr.getdeleter] Status: NAD
  Submitter: Daniel Krügler Opened: 2007-09-27  Last modified: 2008-02-27
    
 
    View all other issues in [util.smartptr.getdeleter].
    
 
    View all issues with NAD status.
    
@@ -16469,7 +18538,7 @@ The following issue was raised by Alf P. Steinbach in c.l.c++.mod:
 
 
    
 According to the recent draft N2369, both the header memory synopsis
-of 20.8 [memory] and 20.8.10.2.11 [util.smartptr.getdeleter] declare:
+of 20.8 [memory] and 20.8.15.2.11 [util.smartptr.getdeleter] declare:
 
    
 
 
    template<class D, class T> D* get_deleter(shared_ptr<T> const& p);
@@ -16484,7 +18553,7 @@ the mutability of the owner (as seen for the both overloads of
 unique_ptr::get_deleter).
 Even the next similar counter-part of get_deleter - the two
 overloads of function::target in the class template function
-synopsis 20.7.16.2 [func.wrap.func] or in 20.7.16.2.5 [func.wrap.func.targ] - do
+synopsis 20.7.15.2 [func.wrap.func] or in 20.7.15.2.5 [func.wrap.func.targ] - do
 properly mirror the const-state of the owner.
 
    
 
@@ -16492,7 +18561,7 @@ properly mirror the const-state of the owner.
 
 
    
 Replace the declarations of get_deleter in the header <memory>
-synopsis of 20.8 [memory] and in 20.8.10.2.11 [util.smartptr.getdeleter] by one of the
+synopsis of 20.8 [memory] and in 20.8.15.2.11 [util.smartptr.getdeleter] by one of the
 following alternatives (A) or (B):
 
    
 
@@ -16733,10 +18802,10 @@ Core has clarified that the definition abstract is adequate. Issue withdrawn by
 
    750. The current definition for is_convertible requires that the type be
 implicitly convertible, so explicit constructors are ignored.
    
 
    Section: 20.6.5 [meta.rel] Status: Dup
- Submitter: Alisdair Meredith Opened: 2007-10-10  Last modified: 2009-07-16
    
+ Submitter: Alisdair Meredith Opened: 2007-10-10  Last modified: 2009-09-13
    
 
    View all other issues in [meta.rel].
    
 
    View all issues with Dup status.
    
-
    Duplicate of: 719
    
+
    Duplicate of: 719
    
 
    Discussion:
    
 
    
 With the pending arrival of explicit conversion functions though, I'm
@@ -16761,9 +18830,15 @@ These two issues should move to OPEN pending AM paper on type traits.
 
 
 
    
-Duplicate of 719 (for our purposes).
+Duplicate of 719 (for our purposes).
 
    
 
+
    [
+Addressed in N2947.
+]
    
+
+
+
 
 
    Proposed resolution:
    
 
@@ -16856,7 +18931,7 @@ NAD.  Insufficient motivation to make any changes.
 
 
    
 
    754. Ambiguous return clause for std::uninitialized_copy
    
-
    Section: 20.8.8.2 [uninitialized.copy] Status: NAD Editorial
+
    Section: 20.8.13.2 [uninitialized.copy] Status: NAD Editorial
  Submitter: Daniel Krügler Opened: 2007-10-15  Last modified: 2008-07-02
    
 
    View all other issues in [uninitialized.copy].
    
 
    View all issues with NAD Editorial status.
    
@@ -16886,7 +18961,7 @@ NAD.  Insufficient motivation to make any changes.
 
 
    
 similarily for N2369, and its corresponding section
-20.8.8.2 [uninitialized.copy].
+20.8.13.2 [uninitialized.copy].
 
    
 
 
    
@@ -16934,7 +19009,7 @@ for std::copy.
 
 
    Proposed resolution:
    
 
    
-Change the wording of the return clause to say (20.8.8.2 [uninitialized.copy]):
+Change the wording of the return clause to say (20.8.13.2 [uninitialized.copy]):
 
    
 
 
    
@@ -16962,6 +19037,8 @@ occur.
 
    756. Container adaptors push
    
 
    Section: 23.3.5 [container.adaptors] Status: NAD Editorial
  Submitter: Paolo Carlini Opened: 2007-10-31  Last modified: 2008-06-18
    
+
    View other active issues in [container.adaptors].
    
+
    View all other issues in [container.adaptors].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
 
    
@@ -17058,7 +19135,6 @@ Addressed by
 
    757. Typo in the synopsis of vector
    
 
    Section: 23.3.6 [vector] Status: NAD Editorial
  Submitter: Paolo Carlini Opened: 2007-11-04  Last modified: 2008-07-02
    
-
    View other active issues in [vector].
    
 
    View all other issues in [vector].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -17186,6 +19262,7 @@ elements of the container. No diagnostic required.
 
    763. Renaming emplace() overloads
    
 
    Section: 23.2.4 [associative.reqmts] Status: NAD
  Submitter: Sylvain Pion Opened: 2007-12-04  Last modified: 2008-03-12
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -19123,7 +21200,7 @@ Addressed by
 
 
    
 
    812. unsolicited multithreading considered harmful?
    
-
    Section: 25.5.1 [alg.sort] Status: NAD Editorial
+
    Section: 25.4.1 [alg.sort] Status: NAD Editorial
  Submitter: Paul McKenney Opened: 2008-02-27  Last modified: 2008-09-17
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -19165,54 +21242,188 @@ This is already covered by 17.6.5.6/20 in N2723.
 
 
 
    
-
    825. Missing rvalues reference stream insert/extract operators?
    
-
    Section: 19.5.2.2 [syserr.errcode.overview], 20.8.10.2.8
-[util.smartptr.shared.io], 22.4.8 [facets.examples], 20.3.6.3
-[bitset.operators], 26.4.6 [complex.ops], 27.6 [stream.buffers], 28.9
-[re.submatch] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2008-04-10  Last modified: 2009-07-13
    
+
    823. identity<void> seems broken
    
+
    Section: 20.3.3 [forward] Status: NAD Editorial
+ Submitter: Walter Brown Opened: 2008-04-09  Last modified: 2009-10-23
    
+
    View all other issues in [forward].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
 
    
-Should the following use rvalues references to stream in insert/extract
-operators?
+N2588 seems to have added an operator() member function to the
+identity<> helper in 20.3.3 [forward].  I believe this change makes it no
+longer possible to instantiate identity<void>, as it would require
+forming a reference-to-void type as this operator()'s parameter type.
 
    
 
-
      
-
    • 19.5.2.2 [syserr.errcode.overview]
      • 
-
    • 20.8.10.2.8 [util.smartptr.shared.io]
      • 
-
    • 22.4.8 [facets.examples]
      • 
-
    • 20.3.6.3 [bitset.operators]
      • 
-
    • 26.4.6 [complex.ops]
      • 
-
    • Doubled signatures in 27.6 [stream.buffers] for character inserters
-(ref 27.7.2.6.4 [ostream.inserters.character])
-+ definition 27.7.2.6.4 [ostream.inserters.character]
      • 
-
    • 28.9 [re.submatch]
      • 
-
    
+
    
+Suggested resolution:  Specialize identity<void> so as not to require
+the member function's presence.
+
    
 
 
    [
-Sophia Antipolis
+Sophia Antipolis:
 ]
    
 
 
 
    
-Agree with the idea in the issue, Alisdair to provide wording.
+
    
+Jens: suggests to add a requires clause to avoid specializing on void.
+
    
+
    
+Alisdair: also consider cv-qualified void.
+
    
+
    
+Alberto provided proposed wording.
+
    
 
    
 
 
    [
-Daniel adds 2009-02-14:
+2009-07-30 Daniel reopens:
 ]
    
 
 
 
    
-The proposal given in the paper
-N2831
-apparently resolves this issue.
-
    
+
    
+This issue became closed, because the ReferentType requirement
+fixed the problem - this is no longer the case. In retrospective it seems
+to be that the root of current issues around std::identity (823, 700,
+939)
+is that it was standardized as something very different (an unconditional
+type mapper) than traditional usage indicated (a function object that should
+derive from std::unary_function), as the SGI definition does. This issue could
+be solved, if std::identity is removed (one proposal of 939), but until this
+has been decided, this issue should remain open. An alternative for
+removing it, would be, to do the following:
+
    
 
-
    [
-Batavia (2009-05):
-]
    
+
      
+
    1. 
+
      
+Let identity stay as a real function object, which would
+now properly
+derive from unary_function:
+
      
+
+
      template <class T> struct identity : unary_function<T, T> {
+  const T& operator()(const T&) const;
+};
+
      
+
      2. 
+
+
    2. 
+
      
+Invent (if needed) a generic type wrapper (corresponding to concept
+IdentityOf),
+e.g. identity_of, and move it's prototype description back to 20.3.3 [forward]:
+
      
+
+
      template <class T> struct identity_of {
+  typedef T type;
+};
+
      
+
+
      
+and adapt the std::forward signature to use identity_of
+instead of identity.
+
      
+
      3. 
+
    
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Mark as NAD Editorial, fixed by 939.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change definition of identity in 20.3.3 [forward], paragraph 2, to:
+
    
+
+
    template <class T>  struct identity {
+    typedef T type;
+
+    requires ReferentType<T>
+      const T& operator()(const T& x) const;
+  };
+
    
+
    ...
    
+
      requires ReferentType<T>
+    const T& operator()(const T& x) const;
+
    
+
+
+
    Rationale:
    
+
    
+The point here is to able to write T& given T and ReferentType is
+precisely the concept that guarantees so, according to N2677
+(Foundational concepts). Because of this, it seems preferable than an
+explicit check for cv void using SameType/remove_cv as it was suggested
+in Sophia. In particular, Daniel remarked that there may be types other
+than cv void which aren't referent types (int[], perhaps?).
+
    
+
+
+
+
+
+
    
+
    825. Missing rvalues reference stream insert/extract operators?
    
+
    Section: 19.5.2.1 [syserr.errcode.overview], 20.8.15.2.8
+[util.smartptr.shared.io], 22.4.8 [facets.examples], 20.3.7.3
+[bitset.operators], 26.4.6 [complex.ops], 27.6 [stream.buffers], 28.9
+[re.submatch] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2008-04-10  Last modified: 2009-10-26
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    Addresses UK 220
    
+
+
    
+Should the following use rvalues references to stream in insert/extract
+operators?
+
    
+
+
      
+
    • 19.5.2.1 [syserr.errcode.overview]
      • 
+
    • 20.8.15.2.8 [util.smartptr.shared.io]
      • 
+
    • 22.4.8 [facets.examples]
      • 
+
    • 20.3.7.3 [bitset.operators]
      • 
+
    • 26.4.6 [complex.ops]
      • 
+
    • Doubled signatures in 27.6 [stream.buffers] for character inserters
+(ref 27.7.2.6.4 [ostream.inserters.character])
++ definition 27.7.2.6.4 [ostream.inserters.character]
      • 
+
    • 28.9 [re.submatch]
      • 
+
    
+
+
    [
+Sophia Antipolis
+]
    
+
+
+
    
+Agree with the idea in the issue, Alisdair to provide wording.
+
    
+
+
    [
+Daniel adds 2009-02-14:
+]
    
+
+
+
    
+The proposal given in the paper
+N2831
+apparently resolves this issue.
+
    
+
+
    [
+Batavia (2009-05):
+]
    
 
 
    
 
    
@@ -19298,6 +21509,231 @@ This is not a part of C99. LWG suggests submitting a paper may be appropriate.
 
 
 
+
    
+
    827. constexpr shared_ptr::shared_ptr()?
    
+
    Section: 20.8.15.2.1 [util.smartptr.shared.const] Status: NAD Editorial
+ Submitter: Peter Dimov Opened: 2008-04-11  Last modified: 2009-10-26
    
+
    View all other issues in [util.smartptr.shared.const].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    
+Would anyone object to making the default constructor of shared_ptr (and
+weak_ptr and enable_shared_from_this) constexpr? This would enable
+static initialization for shared_ptr variables, eliminating another
+unfair advantage of raw pointers.
+
    
+
+
    [
+San Francisco:
+]
    
+
+
+
    
+
    
+It's not clear to us that you can initialize a pointer with the literal
+0 in a constant expression. We need to ask CWG to make sure this works.
+Bjarne has been appointed to do this.
+
    
+
    
+Core got back to us and assured as that nullptr would do the job
+nicely here.
+
    
+
    
+
+
    [
+2009-05-01 Alisdair adds:
+]
    
+
+
+
    
+
    
+I don't believe that constexpr will buy anything in this case.
+shared_ptr/weak_ptr/enable_shared_from_this cannot be literal types as they
+have a non-trivial copy constructor.  As they do not produce literal types,
+then the constexpr default constructor will not guarantee constant
+initialization, and so not buy the hoped for optimization.
+
    
+
    
+I recommend referring this back to Core to see if we can get static
+initialization for types with constexpr constructors, even if they are not
+literal types.  Otherwise this should be closed as NAD.
+
    
+
    
+
+
    [
+2009-05-26 Daniel adds:
+]
    
+
+
+
    
+If Alisdair's 2009-05-01 comment is correct, wouldn't that also make
+constexpr mutex() useless, because this class has a non-trivial
+destructor? (828)
+
    
+
+
    [
+2009-07-21 Alisdair adds:
+]
    
+
+
+
    
+
    
+The feedback from core is that this and similar uses of constexpr
+constructors to force static initialization should be supported.  If
+there are any problems with this in the working draught, we should file
+core issues.
+
    
+
+
    
+Recommend we declare the default constructor constexpr as the issue suggests
+(proposed wording added).
+
    
+
    
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Solved by
+N2994.
+
    
+
+
+
    Proposed resolution:
    
+
    
+Change 20.8.15.2 [util.smartptr.shared] and 20.8.15.2.1 [util.smartptr.shared.const]:
+
    
+
+
    consexpr shared_ptr();
+
    
+
+
    
+Change 20.8.15.3 [util.smartptr.weak] and 20.8.15.3.1 [util.smartptr.weak.const]:
+
    
+
+
    consexpr weak_ptr();
+
    
+
+
    
+Change 20.8.15.4 [util.smartptr.enab] (2 places):
+
    
+
+
    consexpr enable_shared_from_this();
+
    
+
+
+
+
+
+
+
    
+
    828. Static initialization for std::mutex?
    
+
    Section: 30.4.1.1 [thread.mutex.class] Status: NAD Editorial
+ Submitter: Peter Dimov Opened: 2008-04-18  Last modified: 2009-10-26
    
+
    View all other issues in [thread.mutex.class].
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    
+[Note: I'm assuming here that 3.6.2 [basic.start.init]/1 will be fixed.]
+
    
+
    
+Currently std::mutex doesn't support static initialization. This is a
+regression with respect to pthread_mutex_t, which does. I believe that
+we should strive to eliminate such regressions in expressive power where
+possible, both to ease migration and to not provide incentives to (or
+force) people to forego the C++ primitives in favor of pthreads.
+
    
+
+
    [
+Sophia Antipolis:
+]
    
+
+
+
    
+
    
+We believe this is implementable on POSIX, because the initializer-list
+feature and the constexpr feature make this work. Double-check core
+language about static initialization for this case. Ask core for a core
+issue about order of destruction of statically-initialized objects wrt.
+dynamically-initialized objects (should come afterwards). Check
+non-POSIX systems for implementability.
+
    
+
    
+If ubiquitous implementability cannot be assured, plan B is to introduce
+another constructor, make this constexpr, which is
+conditionally-supported. To avoid ambiguities, this new constructor needs
+to have an additional parameter.
+
    
+
    
+
+
    [
+Post Summit:
+]
    
+
+
+
    
+
    
+Jens: constant initialization seems to be ok core-language wise
+
    
+
    
+Consensus: Defer to threading experts, in particular a Microsoft platform expert.
+
    
+
    
+Lawrence to send e-mail to Herb Sutter, Jonathan Caves, Anthony Wiliams,
+Paul McKenney, Martin Tasker, Hans Boehm, Bill Plauger, Pete Becker,
+Peter Dimov to alert them of this issue.
+
    
+
    
+Lawrence: What about header file shared with C? The initialization
+syntax is different in C and C++.
+
    
+
    
+Recommend Keep in Review
+
    
+
    
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+Keep in Review status pending feedback from members of the Concurrency subgroup.
+
    
+
+
    [
+See related comments from Alisdiar and Daniel in 827.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Solved by
+N2994.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change 30.4.1.1 [thread.mutex.class]:
+
    
+
+
    class mutex {
+public:
+  constexpr mutex();
+  ...
+
    
+
+
+
+
+
 
    
 
    830. Incomplete list of char_traits specializations
    
 
    Section: 21.2 [char.traits] Status: NAD Editorial
@@ -19604,7 +22040,7 @@ Thus implementations are given latitude in determining correspondence.
 
    
 
 
    
-Change 19.5.2.2 [syserr.errcode.overview] Class error_code overview as indicated:
+Change 19.5.2.1 [syserr.errcode.overview] Class error_code overview as indicated:
 
    
 
 
    class error_code {
@@ -19622,7 +22058,7 @@ private:
 
    
 
 
    
-Change 19.5.2.3 [syserr.errcode.constructors] Class error_code constructors as indicated:
+Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors as indicated:
 
    
 
 
    
@@ -19640,7 +22076,7 @@ Change 19.5.2.3 [syserr.errcode.constructors] Class error_code construc
 
    
 
 
    
-Change 19.5.2.4 [syserr.errcode.modifiers] Class error_code modifiers  as indicated:
+Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers  as indicated:
 
    
 
 
    
@@ -19655,7 +22091,7 @@ Change 19.5.2.4 [syserr.errcode.modifiers] Class error_code modifiers
 
    
 
 
    
-Change 19.5.2.5 [syserr.errcode.observers] Class error_code observers  as indicated:
+Change 19.5.2.4 [syserr.errcode.observers] Class error_code observers  as indicated:
 
    
 
 
    
@@ -19671,7 +22107,7 @@ Change 19.5.2.5 [syserr.errcode.observers] Class error_code observers
 
    
 
 
    
-Change 19.5.3.2 [syserr.errcondition.overview] Class error_condition overview   as indicated:
+Change 19.5.3.1 [syserr.errcondition.overview] Class error_condition overview   as indicated:
 
    
 
 
    
@@ -19691,7 +22127,7 @@ private:
 
    
 
 
    
-Change 19.5.3.3 [syserr.errcondition.constructors] Class error_condition constructors as indicated:
+Change 19.5.3.2 [syserr.errcondition.constructors] Class error_condition constructors as indicated:
 
    
 
 
    
@@ -19709,7 +22145,7 @@ Change 19.5.3.3 [syserr.errcondition.constructors] Class error_condition
 
 
    
-Change 19.5.3.4 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated:
+Change 19.5.3.3 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated:
 
    
 
 
    
@@ -19724,7 +22160,7 @@ Change 19.5.3.4 [syserr.errcondition.modifiers] Class error_condition m
 
    
 
 
    
-Change 19.5.3.5 [syserr.errcondition.observers] Class error_condition observers as indicated:
+Change 19.5.3.4 [syserr.errcondition.observers] Class error_condition observers as indicated:
 
    
 
 
    
@@ -20029,7 +22465,7 @@ already there.
 
    
 
    839. Maps and sets missing splice operation
    
 
    Section: 23.4 [associative], 23.5 [unord] Status: NAD Future
- Submitter: Alan Talbot Opened: 2008-05-18  Last modified: 2009-07-16
    
+ Submitter: Alan Talbot Opened: 2008-05-18  Last modified: 2009-09-20
    
 
    View all other issues in [associative].
    
 
    View all issues with NAD Future status.
    
 
    Discussion:
    
@@ -20141,18 +22577,189 @@ that demonstrates that it works.
 NAD Future.
 
    
 
+
    [
+2009-09-19 Howard adds:
+]
    
 
 
-
    Proposed resolution:
    
+
    
+
    
+I'm not disagreeing with the NAD Future resolution.  But when the future gets
+here, here is a possibility worth exploring:
+
    
 
+
    
+
    
+Add to the "unique" associative containers:
+
    
 
+
    typedef details      node_ptr;
 
+node_ptr             remove(const_iterator p);
+pair<iterator, bool> insert(node_ptr&& nd);
+iterator             insert(const_iterator p, node_ptr&& nd);
+
    
 
+
    
+And add to the "multi" associative containers:
+
    
 
-
    
-
    840. pair default template argument
    
-
    Section: 20.3.3 [pairs] Status: NAD
- Submitter: Thorsten Ottosen Opened: 2008-05-23  Last modified: 2008-06-18
    
+
    typedef details node_ptr;
+
+node_ptr remove(const_iterator p);
+iterator insert(node_ptr&& nd);
+iterator insert(const_iterator p, node_ptr&& nd);
+
    
+
+
    
+Container::node_ptr is a smart pointer much like unique_ptr.
+It owns a node obtained from the container it was removed from.  It maintains a
+reference to the allocator in the container so that it can properly deallocate
+the node if asked to, even if the allocator is stateful.  This being said, the
+node_ptr can not outlive the container for this reason.
+
    
+
+
    
+The node_ptr offers "const-free" access to the node's
+value_type.
+
    
+
+
    
+With this interface, clients have a great deal of flexibility:
+
    
+
+
      
+
    • 
+A client can remove a node from one container, and insert it into another
+(without any heap allocation).  This is the splice functionality this issue
+asks for.
+
      • 
+
    • 
+A client can remove a node from a container, change its key or value, and insert
+it back into the same container, or another container, all without the cost of
+allocating a node.
+
      • 
+
    • 
+If the Compare function is nothrow (which is very common), then this functionality
+is nothrow unless modifying the value throws.  And if this does throw, it does
+so outside of the containers involved.
+
      • 
+
    • 
+If the Compare function does throw, the insert function will have the
+argument nd retain ownership of the node.
+
      • 
+
    • 
+The node_ptr should be independent of the Compare parameter
+so that a node can be transferred from set<T, C1, A>
+to set<T, C2, A> (for example).
+
      • 
+
    
+
+
    
+Here is how the customer might use this functionality:
+
    
+
+
      
+
    • 
+
      
+Splice a node from one container to another:
+
      
+
      m2.insert(m1.remove(i));
+
      
+
      • 
+
+
    • 
+
      
+Change the "key" in a std::map without the cost of node reallocation:
+
      
+
      auto p = m.remove(i);
+p->first = new_key;
+m.insert(std::move(p));
+
      
+
      • 
+
+
    • 
+
      
+Change the "value" in a std::set without the cost of node reallocation:
+
      
+
      auto p = s.remove(i);
+*p = new_value;
+s.insert(std::move(p));
+
      
+
      • 
+
+
    • 
+
      
+Move a move-only or heavy object out of an associative container (as opposed to
+the proposal in 1041):
+
      
+
      MoveOnly x = std::move(*s.remove(i));
+
      
+
        
+
      1. 
+remove(i) transfers ownership of the node from the set to a temporary
+node_ptr.
+
        2. 
+
      2. 
+The node_ptr is dereferenced, and that non-const reference is sent to
+move to cast it to an rvalue.
+
        3. 
+
      3. 
+The rvalue MoveOnly is move constructed into x from
+the node_ptr.
+
        4. 
+
      4. 
+~node_ptr() destructs the moved-from MoveOnly and deallocates
+the node.
+
        5. 
+
      
+
+
      
+Contrast this with the 1041 solution:
+
      
+
      MoveOnly x = std::move(s.extract(i).first);
+
      
+
+
      
+The former requires one move construction for x while the latter
+requires two (one into the pair and then one into x).  Either
+of these constructions can throw (say if there is only a copy constructor for
+x).  With the former, the point of throw is outside of the container
+s, after the element has been removed from the container.  With the latter,
+one throwing construction takes place prior to the removal of the element, and
+the second takes place after the element is removed.
+
      
+
+
      • 
+
    
+
+
    
+The "node insertion" API maintains the API associated with inserting value_types
+so the customer can use familiar techniques for getting an iterator to the 
+inserted node, or finding out whether it was inserted or not for the "unique"
+containers.
+
    
+
+
    
+Lightly prototyped.  No implementation problems.  Appears to work great
+for the client.
+
    
+
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
+
+
+
+
+
    
+
    840. pair default template argument
    
+
    Section: 20.3.4 [pairs] Status: NAD
+ Submitter: Thorsten Ottosen Opened: 2008-05-23  Last modified: 2008-06-18
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
 
    View all issues with NAD status.
    
@@ -20175,7 +22782,7 @@ Change the synopsis in 20.3 [utility] to read:
 
    
 
 
    
-Change 20.3.3 [pairs] to read:
+Change 20.3.4 [pairs] to read:
 
    
 
 
    namespace std {
@@ -20438,7 +23045,6 @@ and macros are required.
 
    849. missing type traits to compute root class and derived class of types in a class hierachy
    
 
    Section: 20.6.7 [meta.trans.other] Status: NAD
  Submitter: Thorsten Ottosen Opened: 2008-06-05  Last modified: 2008-09-16
    
-
    View other active issues in [meta.trans.other].
    
 
    View all other issues in [meta.trans.other].
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -20521,63 +23127,58 @@ as an accessible unambiguous direct base class. If no such type exists, the memb
 
 
 
    
-
    855. capacity() and reserve() for deque?
    
-
    Section: 23.3.2.2 [deque.capacity] Status: NAD
- Submitter: Hervé Brönnimann Opened: 2008-06-11  Last modified: 2008-09-22
    
-
    View all other issues in [deque.capacity].
    
-
    View all issues with NAD status.
    
+
    851. simplified array construction
    
+
    Section: 23.3.1 [array] Status: NAD Future
+ Submitter: Benjamin Kosnik Opened: 2008-06-05  Last modified: 2009-10-23
    
+
    View all other issues in [array].
    
+
    View all issues with NAD Future status.
    
 
    Discussion:
    
 
    
-The main point is that capacity can be viewed as a mechanism to  
-guarantee the validity of iterators when only push_back/pop_back
-operations are used.  For vector, this goes with reallocation.  For  
-deque, this is a bit more subtle:  capacity() of a deque may shrink,  
-whereas that of vector doesn't.   In a circular buffer impl. of the  
-map, as Howard did, there is very similar notion of capacity: as long  
-as size() is less than B * (total size of the map - 2), it is  
-guaranteed that no iterator is invalidated after any number of  
-push_front/back and pop_front/back operations.  But this does not  
-hold for other implementations.
+This is an issue that came up on the libstdc++ list, where a
+discrepancy between "C" arrays and C++0x's std::array was pointed
+out.
 
    
+
 
    
-Still, I believe, capacity() can be defined by size() +  how many  
-push_front/back minus pop_front/back that can be performed before  
-terators are invalidated.  In a classical impl., capacity() = size()
-+  the min distance to either "physical" end of the deque (i.e.,  
-counting the empty space in the last block plus all the blocks until  
-the end of the map of block pointers).  In Howard's circular buffer  
-impl., capacity() = B * (total size of the map - 2) still works with  
-this definition, even though the guarantee could be made stronger.
+In "C," this array usage is possible:
 
    
+
+
    int ar[] = {1, 4, 6};
+
    
+
 
    
-A simple picture of a deque:
+But for C++, 
 
    
-
    A-----|----|-----|---F+|++++|++B--|-----|-----Z
+
+
    std::array<int> a = { 1, 4, 6 }; // error
 
    
+
 
    
-(A,Z mark the beginning/end, | the block boundaries, F=front, B=back,  
-and - are uninitialized, + are initialized)
-In that picture:  capacity = size() + min(dist(A,F),dist(B,Z)) = min 
-(dist(A,B),dist(F,Z)).
+Instead, the second parameter of the array template must be
+explicit, like so:
 
    
+
+
    std::array<int, 3> a = { 1, 4, 6 };
+
    
+
 
    
-Reserve(n) can grow the map of pointers and add possibly a number of  
-empty blocks to it, in order to guarantee that the next n-size()
-push_back/push_front operations will not invalidate iterators, and  
-also will not allocate (i.e. cannot throw).  The second guarantee is  
-not essential and can be left as a QoI.  I know well enough existing  
-implementations of deque (sgi/stl, roguewave, stlport, and  
-dinkumware) to know that either can be implemented with no change to  
-the existing class layout and code, and only a few modifications if  
-blocks are pre-allocated (instead of always allocating a new block,  
-check if the next entry in the map of block pointers is not zero).
+Doug Gregor proposes the following solution, that assumes
+generalized initializer lists.
 
    
+
+
    template<typename T, typename... Args>
+inline array<T, sizeof...(Args)> 
+make_array(Args&&... args) 
+{ return { std::forward<Args>(args)... };  }
+
    
+
 
    
-Due to the difference with vector, wording is crucial.  Here's a  
-proposed wording to make things concrete;  I tried to be reasonably  
-careful but please double-check me:
+Then, the way to build an array from a list of unknown size is:
 
    
 
+
    auto a = make_array<T>(1, 4, 6);
+
    
+
 
    [
 San Francisco:
 ]
    
@@ -20585,105 +23186,442 @@ San Francisco:
 
 
    
 
    
-Hans: should the Returns clause for capacity read "1 Returns: A lower
-bound..." rather than "1 Returns: An upper bound..."
+Benjamin: Move to Ready?
 
    
 
    
-Howard: maybe what's needed is capacity_front and capacity_back. In
-fact, I think I implemented a deque that had these members as
-implementation details.
+Bjarne: I'm not convinced this is useful enough to add, so I'd like us
+to have time to reflect on it.
+
    
+
    
+Alisdair: the constraints are wrong, they should be
+
    
+
    template<ValueType T, ValueType... Args>
+requires Convertible<Args, T>...
+array<T, sizeof...(Args)> make_array(Args&&... args);
+
    
+
    
+Alidair: this would be useful if we had a constexpr version.
+
    
+
    
+Bjarne: this is probably useful for arrays with a small number of
+elements, but it's not clearly useful otherwise.
+
    
+
    
+Consensus is to move to Open.
 
    
 
    
 
+
    [
+2009-06-07 Daniel adds:
+]
    
 
 
-
    Proposed resolution:
    
+
    
+
    
+I suggest a fix and a simplification of the current proposal: Recent
+prototyping by
+Howard showed, that a fix is required because narrowing conversion
+8.5.4 [dcl.init.list]/6 b.3
+would severely limit the possible distribution of argument types, e.g.
+the expression
+make_array<double>(1, 2.0) is ill-formed, because the narrowing
+happens inside the
+function body where no constant expressions exist anymore. Furthermore
+given e.g.
+
    
+
    int f();
+double g();
+
    
+
    
+we probably want to support
+
    
+
    make_array<double>(f(), g());
+
    
 
 
    
-Add new signatures to synopsis in 23.3.2 [deque]:
+as well. To make this feasible, the currently suggested expansion
 
    
 
-
    size_type capacity() const;
-bool reserve(size_type n);
+
    { std::forward<Args>(args)... }
 
    
 
 
    
-Add new signatures to 23.3.2.2 [deque.capacity]:
+needs to be replaced by
 
    
 
-
    
-
    size_type capacity() const;
-
    
-
    
+
    { static_cast<T>(std::forward<Args>(args))... }
+
    
+
 
    
-1 Returns: An upper bound on n + max(n_f - m_f, n_b - m_b)  such  
-that, for any sequence of n_f push_front, m_f pop_front, n_b  
-push_back, and m_b pop_back operations, interleaved in any order,  
-starting with the current deque of size n, the deque does not  
-invalidate any of its iterators except to the erased elements.
+which is safe, because we already ensure convertibility via the
+element-wise Convertible<Args, T> requirement. Some other fixes are
+necessary: The ValueType requirement for the function parameters
+is invalid, because all lvalue arguments will deduce to an lvalue-reference,
+thereby no longer satisfying this requirement.
 
    
+
 
    
-2 Remarks:  Unlike a vector's capacity, the capacity of a deque can  
-decrease after a sequence of insertions at both ends, even if none of  
-the operations caused the deque to invalidate any of its iterators  
-except to the erased elements.
+The suggested simplification is to provide a default-computed effective
+type for the result array based on common_type and decay, in
+unconstrained form:
 
    
-
    
-
    
 
-
    
-
    bool reserve(size_type n);
-
    
-
    
+
    template<typename... Args>
+array<typename decay<typename common_type<Args...>::type>::type,
+sizeof...(Args)>
+make_array(Args&&... args);
+
    
+
 
    
-2 Effects: A directive that informs a deque of a planned sequence of  
-push_front, pop_front, push_back, and pop_back operations, so that it  
-can manage iterator invalidation accordingly. After reserve(),  
-capacity() is greater or equal to the argument of reserve if this  
-operation returns true; and equal to the previous value of capacity()
-otherwise.  If an exception is thrown, there are no effects.
-
    
+The approach used below is similar to that of make_pair and make_tuple
+using a symbol C to represent the decayed common type [Note: Special
+handling of reference_wrapper types is intentionally not provided, because
+our target has so satisfy ValueType, thus under the revised proposal only
+an all-reference_wrapper-arguments would be well-formed and an array of
+reference_wrapper will be constructed]. I do currently not suggest to
+add new concepts reflecting decay and common_type, but an implementor will
+need something like this to succeed. Note that we use a similar fuzziness for
+make_pair and make_tuple currently. This fuzziness is not related to
+the currently
+missing Constructible<Vi, Ti&&> requirement for those functions. The following
+proposal fixes that miss for make_array. If the corresponding C type
+deduction is
+explicitly wanted for standardization, here the implementation
+
    
+
+
    auto concept DC<typename... T> {
+  typename type = typename decay<typename common_type<T...>::type>::type;
+}
+
    
+
 
    
-3 Returns: true if iterators are invalidated as a result of this  
-operation, and false otherwise.
+where C is identical to DC<Args...>::type in the proposed resolution below.
 
    
 
    
-4 Complexity: It does not change the size of the sequence and takes  
-at most linear time in n.
+I intentionally added no further type relation between type and the concept
+template parameters, but instead added this requirement below to make
+the specification as transparent as possible. As written this concept is
+satisfied, if the corresponding associated type exists.
 
    
+
+
    Suggested Resolution:
    
+
+
      
+
    1. 
 
      
-5 Throws: length_error if n > max_size().
+Add to the array synopsis in 23.3 [sequences]:
 
      
+
      
+template<ReferentType... Args>
+requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
+array<C, sizeof...(Args)>
+make_array(Args&&... args);
+
+
      
+
      2. 
+
+
    2. 
 
      
-6 Remarks: It is guaranteed that no invalidation takes place during a  
-sequence of insert or erase operations at either end that happens  
-after a call to reserve() except to the erased elements, until the  
-time when an insertion would make max(n_f-m_f, n_b-m_b) larger than  
-capacity(), where n_f is the number of push_front, m_f of pop_front,  
-n_b of push_back, and m_b of pop_back operations since the call to  
-reserve().
+Append after 23.3.1.7 [array.tuple] Tuple interface to class template array
+the following new section:
 
      
+
      
 
      
-7        An implementation is free to pre-allocate buffers so as to  
-offer the additional guarantee that no exception will be thrown  
-during such a sequence other than by the element constructors.
+23.4.1.7 Array creation functions [array.creation]
 
      
-
      
-
    
 
-
    
-And 23.3.2.3 [deque.modifiers] para 1, can be enhanced:
-
    
+
    
+template<ReferentType... Args>
+requires ValueType<C> && IdentityOf<Args> && Constructible<C, Args&&>...
+array<C, sizeof...(Args)>
+make_array(Args&&... args);
+
    
 
 
    
-1 Effects: An insertion in the middle of the deque invalidates all the iterators and references to elements of the
-deque. An insertion at either end of the deque invalidates all the iterators to the deque,
-unless provisions have been made with reserve,
-but has no effect on the validity of references to elements of the deque.
+
    
+Let C be decay<common_type<Args...>::type>::type.
+
    
+
    
+Returns: an array<C, sizeof...(Args)> initialized with
+{ static_cast<C>(std::forward<Args>(args))... }.
+
    
+
    
 
    
 
+
    • 
 
-
    Rationale:
    
+
+
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+
    
+The proposed resolution uses concepts.
+
    
+
    
+Daniel to rewrite the proposed resolution.
+
    
+
    
+Leave Open.
+
    
+
    
+
+
    [
+2009-07-25 Daniel provides rewritten proposed resolution.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+Argument for NAD future: everything about this could be added on. This
+does not require changes to the existing text.
+
    
+
+
+
+
    Proposed resolution:
    
+
+
      
+
    1. 
+
      
+Add to the array synopsis in 23.3 [sequences]:
+
      
+
+
      template<class... Args>
+  array<CT, sizeof...(Args)>
+  make_array(Args&&... args);
+
      
+
      2. 
+
+
    2. 
+
      
+Append after 23.3.1.7 [array.tuple] "Tuple interface to class template array" the
+following new section:
+
      
+
+
      
+
      
+XX.X.X.X Array creation functions [array.creation]
+
      
+
+
      
+template<class... Args>
+array<CT, sizeof...(Args)>
+make_array(Args&&... args)
+
      
+
+
      
+
      
+Let CT be decay<common_type<Args...>::type>::type.
+
      
+
      
+Returns: An array<CT, sizeof...(Args)> initialized with {
+static_cast<CT>(std::forward<Args>(args))... }.
+
      
+
+
      
+[Example:
+
      
+
      
+int i = 0; int& ri = i;
+make_array(42u, i, 2.78, ri);
+
      
+
      
+returns an array of type
+
      
+
      
+array<double, 4>
+
      
+
+
      
+—end example]
+
      
+
      
+
      
+
      3. 
+
+
    
+
+
+
+
+
+
+
+
+
    
+
    855. capacity() and reserve() for deque?
    
+
    Section: 23.3.2.2 [deque.capacity] Status: NAD
+ Submitter: Hervé Brönnimann Opened: 2008-06-11  Last modified: 2008-09-22
    
+
    View all other issues in [deque.capacity].
    
+
    View all issues with NAD status.
    
+
    Discussion:
    
+
    
+The main point is that capacity can be viewed as a mechanism to  
+guarantee the validity of iterators when only push_back/pop_back
+operations are used.  For vector, this goes with reallocation.  For  
+deque, this is a bit more subtle:  capacity() of a deque may shrink,  
+whereas that of vector doesn't.   In a circular buffer impl. of the  
+map, as Howard did, there is very similar notion of capacity: as long  
+as size() is less than B * (total size of the map - 2), it is  
+guaranteed that no iterator is invalidated after any number of  
+push_front/back and pop_front/back operations.  But this does not  
+hold for other implementations.
+
    
+
    
+Still, I believe, capacity() can be defined by size() +  how many  
+push_front/back minus pop_front/back that can be performed before  
+terators are invalidated.  In a classical impl., capacity() = size()
++  the min distance to either "physical" end of the deque (i.e.,  
+counting the empty space in the last block plus all the blocks until  
+the end of the map of block pointers).  In Howard's circular buffer  
+impl., capacity() = B * (total size of the map - 2) still works with  
+this definition, even though the guarantee could be made stronger.
+
    
+
    
+A simple picture of a deque:
+
    
+
    A-----|----|-----|---F+|++++|++B--|-----|-----Z
+
    
+
    
+(A,Z mark the beginning/end, | the block boundaries, F=front, B=back,  
+and - are uninitialized, + are initialized)
+In that picture:  capacity = size() + min(dist(A,F),dist(B,Z)) = min 
+(dist(A,B),dist(F,Z)).
+
    
+
    
+Reserve(n) can grow the map of pointers and add possibly a number of  
+empty blocks to it, in order to guarantee that the next n-size()
+push_back/push_front operations will not invalidate iterators, and  
+also will not allocate (i.e. cannot throw).  The second guarantee is  
+not essential and can be left as a QoI.  I know well enough existing  
+implementations of deque (sgi/stl, roguewave, stlport, and  
+dinkumware) to know that either can be implemented with no change to  
+the existing class layout and code, and only a few modifications if  
+blocks are pre-allocated (instead of always allocating a new block,  
+check if the next entry in the map of block pointers is not zero).
+
    
+
    
+Due to the difference with vector, wording is crucial.  Here's a  
+proposed wording to make things concrete;  I tried to be reasonably  
+careful but please double-check me:
+
    
+
+
    [
+San Francisco:
+]
    
+
+
+
    
+
    
+Hans: should the Returns clause for capacity read "1 Returns: A lower
+bound..." rather than "1 Returns: An upper bound..."
+
    
+
    
+Howard: maybe what's needed is capacity_front and capacity_back. In
+fact, I think I implemented a deque that had these members as
+implementation details.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
+
    
+Add new signatures to synopsis in 23.3.2 [deque]:
+
    
+
+
    size_type capacity() const;
+bool reserve(size_type n);
+
    
+
+
    
+Add new signatures to 23.3.2.2 [deque.capacity]:
+
    
+
+
    
+
    size_type capacity() const;
+
    
+
    
+
    
+1 Returns: An upper bound on n + max(n_f - m_f, n_b - m_b)  such  
+that, for any sequence of n_f push_front, m_f pop_front, n_b  
+push_back, and m_b pop_back operations, interleaved in any order,  
+starting with the current deque of size n, the deque does not  
+invalidate any of its iterators except to the erased elements.
+
    
+
    
+2 Remarks:  Unlike a vector's capacity, the capacity of a deque can  
+decrease after a sequence of insertions at both ends, even if none of  
+the operations caused the deque to invalidate any of its iterators  
+except to the erased elements.
+
    
+
    
+
    
+
+
    
+
    bool reserve(size_type n);
+
    
+
    
+
    
+2 Effects: A directive that informs a deque of a planned sequence of  
+push_front, pop_front, push_back, and pop_back operations, so that it  
+can manage iterator invalidation accordingly. After reserve(),  
+capacity() is greater or equal to the argument of reserve if this  
+operation returns true; and equal to the previous value of capacity()
+otherwise.  If an exception is thrown, there are no effects.
+
    
+
    
+3 Returns: true if iterators are invalidated as a result of this  
+operation, and false otherwise.
+
    
+
    
+4 Complexity: It does not change the size of the sequence and takes  
+at most linear time in n.
+
    
+
    
+5 Throws: length_error if n > max_size().
+
    
+
    
+6 Remarks: It is guaranteed that no invalidation takes place during a  
+sequence of insert or erase operations at either end that happens  
+after a call to reserve() except to the erased elements, until the  
+time when an insertion would make max(n_f-m_f, n_b-m_b) larger than  
+capacity(), where n_f is the number of push_front, m_f of pop_front,  
+n_b of push_back, and m_b of pop_back operations since the call to  
+reserve().
+
    
+
    
+7        An implementation is free to pre-allocate buffers so as to  
+offer the additional guarantee that no exception will be thrown  
+during such a sequence other than by the element constructors.
+
    
+
    
+
    
+
+
    
+And 23.3.2.3 [deque.modifiers] para 1, can be enhanced:
+
    
+
+
    
+1 Effects: An insertion in the middle of the deque invalidates all the iterators and references to elements of the
+deque. An insertion at either end of the deque invalidates all the iterators to the deque,
+unless provisions have been made with reserve,
+but has no effect on the validity of references to elements of the deque.
+
    
+
+
+
    Rationale:
    
 Complication outweighs the benefit.
 
 
@@ -20692,13 +23630,13 @@ Complication outweighs the benefit.
 
 
    
 
    862. Impossible complexity for 'includes'
    
-
    Section: 25.5.5.1 [includes] Status: NAD Editorial
+
    Section: 25.4.5.1 [includes] Status: NAD Editorial
  Submitter: Alisdair Meredith Opened: 2008-07-02  Last modified: 2009-07-13
    
 
    View all other issues in [includes].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
 
    
-In 25.5.5.1 [includes] the complexity is "at most -1 comparisons" if passed
+In 25.4.5.1 [includes] the complexity is "at most -1 comparisons" if passed
 two empty ranges.  I don't know how to perform a negative number of
 comparisions!
 
    
@@ -20722,7 +23660,7 @@ This same issue also applies to:
 
 
    
 Suggest NAD. The complexity of empty ranges is -1 in other places in the
-standard. See 25.5.4 [alg.merge] merge and
+standard. See 25.4.4 [alg.merge] merge and
 inplace_merge, and forward_list merge, for example.
 The time and effort to find and fix all places in the standard where
 empty range[s] result in negative complexity isn't worth the very
@@ -20821,7 +23759,6 @@ Move to NAD.
 
    864. Defect in atomic wording
    
 
    Section: 29.6 [atomics.types.operations] Status: NAD Editorial
  Submitter: Anthony Williams Opened: 2008-07-10  Last modified: 2008-09-17
    
-
    View other active issues in [atomics.types.operations].
    
 
    View all other issues in [atomics.types.operations].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -21041,7 +23978,7 @@ Post Summit Daniel adds:
 
 
    
 The proposed resolution needs to be "conceptualized". Currently we have
-in 14.10.4 [concept.support] only concept IntegralType
+in  [concept.support] only concept IntegralType
 for all "integral types", thus indeed the current Container
 concept and Iterator concepts are sufficiently satisfied with "integral
 types". If the changes are applied, we might ask core for concept
@@ -21085,7 +24022,7 @@ concepts.
       X::difference_type cannot be char or
       wchar_t, but could be one of the signed or unsigned integer
       types as appropriate.
-      X [allocator.requirements] table 40...
+      20.2.2 [allocator.requirements] table 40...
     
    
     
    
       Table 40: Allocator requirements
@@ -21319,7 +24256,7 @@ concepts.
     
    
 
     
    
-      24.2 [iterator.concepts] paragraph 1...
+      X [iterator.concepts] paragraph 1...
     
    
     
    
       Iterators are a generalization of pointers that allow a C++ program to
@@ -22052,16 +24989,186 @@ specification with a "Throws: Nothing." clause.
 
 
 
    
-
    884. shared_ptr swap
    
-
    Section: 20.8.10.2.4 [util.smartptr.shared.mod] Status: NAD Editorial
- Submitter: Jonathan Wakely Opened: 2008-09-15  Last modified: 2009-07-13
    
+
    879. Atomic load const qualification
    
+
    Section: 29 [atomics] Status: NAD Editorial
+ Submitter: Alexander Chemeris Opened: 2008-08-24  Last modified: 2009-10-26
    
+
    View all other issues in [atomics].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
-
    #include <memory>
-#include <cassert>
+
    
+The atomic_address type and atomic<T*> specialization provide atomic
+updates to pointers.  However, the current specification requires
+that the types pointer be to non-const objects.  This restriction
+is unnecessary and unintended.
+
    
 
-struct A { };
-struct B : A { };
+
    [
+Summit:
+]
    
+
+
    
+Move to review.  Lawrence will first check with Peter whether the
+current examples are sufficient, or whether they need to be expanded to
+include all cases.
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Lawrence will handle all issues relating to atomics in a single paper.
+
    
+
    
+LWG will defer discussion on atomics until that paper appears.
+
    
+
    
+Move to Open.
+
    
+
    
+
+
    [
+2009-08-17 Handled by
+N2925.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Solved by
+N2992.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Add const qualification to the pointer values of the atomic_address
+and atomic<T*> specializations.  E.g.
+
    
+
+
    typedef struct atomic_address {
+   void store(const void*, memory_order = memory_order_seq_cst) volatile;
+   void* exchange( const void*, memory_order = memory_order_seq_cst) volatile;
+   bool compare_exchange( const void*&, const void*,
+                          memory_order, memory_order) volatile;
+   bool compare_exchange( const void*&, const void*,
+                          memory_order = memory_order_seq_cst ) volatile;
+   void* operator=(const void*) volatile;
+} atomic_address;
+
+void atomic_store(volatile atomic_address*, const void*);
+void atomic_store_explicit(volatile atomic_address*, const void*,
+                          memory_order);
+void* atomic_exchange(volatile atomic_address*, const void*);
+void* atomic_exchange_explicit(volatile atomic_address*, const void*,
+                              memory_order);
+bool atomic_compare_exchange(volatile atomic_address*,
+                            const void**, const void*);
+bool atomic_compare_exchange_explicit(volatile atomic_address*,
+                                     const void**, const void*,
+                                     memory_order, memory_order);
+
    
+
+
+
+
+
+
    
+
    880. Missing atomic exchange parameter
    
+
    Section: 29 [atomics] Status: NAD Editorial
+ Submitter: Lawrence Crowl Opened: 2008-08-24  Last modified: 2009-10-26
    
+
    View all other issues in [atomics].
    
+
    View all issues with NAD Editorial status.
    
+
    Duplicate of: 942
    
+
    Discussion:
    
+
    
+The atomic_exchange and atomic_exchange_explicit functions seem to
+be inconsistently missing parameters.
+
    
+
+
    [
+Post Summit:
+]
    
+
+
+
    
+
    
+Lawrence: Need to write up a list for Pete with details.
+
    
+
    
+Detlef: Should not be New, we already talked about in Concurrency group.
+
    
+
    
+Recommend Open.
+
    
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Lawrence will handle all issues relating to atomics in a single paper.
+
    
+
    
+LWG will defer discussion on atomics until that paper appears.
+
    
+
    
+Move to Open.
+
    
+
    
+
+
    [
+2009-08-17 Handled by
+N2925.
+]
    
+
+
+
    [
+2009-10 Santa Cruz:
+]
    
+
+
+
    
+NAD Editorial.  Solved by
+N2992.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Add the appropriate parameters.  For example,
+
    
+
+
    bool atomic_exchange(volatile atomic_bool*, bool);
+bool atomic_exchange_explicit(volatile atomic_bool*, bool, memory_order);
+
    
+
+
+
+
+
+
    
+
    884. shared_ptr swap
    
+
    Section: 20.8.15.2.4 [util.smartptr.shared.mod] Status: NAD Editorial
+ Submitter: Jonathan Wakely Opened: 2008-09-15  Last modified: 2009-07-13
    
+
    View all issues with NAD Editorial status.
    
+
    Discussion:
    
+
    #include <memory>
+#include <cassert>
+
+struct A { };
+struct B : A { };
 
 int main()
 {
@@ -22134,7 +25241,6 @@ Recommend NAD Editorial, fixed by
 
    892. Forward_list issues...
    
 
    Section: 23.3.3.5 [forwardlist.ops] Status: NAD Editorial
  Submitter: Ed Smith-Rowland Opened: 2008-09-15  Last modified: 2009-03-09
    
-
    View other active issues in [forwardlist.ops].
    
 
    View all other issues in [forwardlist.ops].
    
 
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
@@ -22199,7 +25305,7 @@ Move to NAD Editorial, Pending. Howard to open a new issue to handle the
 problems with the complexity requirements.
 
    
 
    
-Opened 897.
+Opened 897.
 
    
 
    
 
@@ -22251,88 +25357,418 @@ clauses which are not constraints on user code, such as that on
 
 
 
    
-
    901. insert iterators can move from lvalues
    
-
    Section: 24.7.5 [insert.iterator] Status: NAD
- Submitter: Alisdair Meredith Opened: 2008-09-24  Last modified: 2009-07-13
    
-
    View all issues with NAD status.
    
+
    897. Forward_list issues... Part 2
    
+
    Section: 23.3.3.4 [forwardlist.modifiers] Status: NAD Editorial
+ Submitter: Howard Hinnant Opened: 2008-09-22  Last modified: 2009-10-20
    
+
    View all issues with NAD Editorial status.
    
 
    Discussion:
    
-
    Addresses UK 282
    
+
    
+This issue was split off from 892 at the request of the LWG.
+
    
+
+
    [
+San Francisco:
+]
    
+
 
+
    
 
    
-The requires clause on the const T & overloads in
-back_insert_iterator/front_insert_iterator/insert_iterator mean that the
-assignment operator will implicitly move from lvalues of a move-only type.
+This issue is more complicated than it looks.
 
    
 
    
-Suggested resolutions are:
+paragraph 47: replace each (first, last) with (first, last]
 
    
-
      
+
      
+add a statement after paragraph 48 that complexity is O(1)
+
      
+
      
+remove the complexity statement from the first overload of splice_after
+
      
+
      
+We may have the same problems with other modifiers, like erase_after.
+Should it require that all iterators in the range (position, last] be
+dereferenceable?
+
      
+
    
+
+
    
+There are actually 3 issues here:
+
    
+
+
      
 
    1. 
-Add another overload with a negative constraint on copy-constructible
-and flag it "= delete".
+
      
+What value should erase_after return?  With list, code often
+looks like:
+
      
+
      for (auto i = l.begin(); i != l.end();)
+{
+    // inspect *i and decide if you want to erase it
+    // ...
+    if (I want to erase *i)
+        i = l.erase(i);
+    else
+        ++i;
+}
+
      
+
      
+I.e. the iterator returned from erase is useful for setting up the
+logic for operating on the next element.  For forward_list this might
+look something like:
+
      
+
      auto i = fl.before_begin();
+auto ip1 = i;
+for (++ip1; ip1 != fl.end(); ++ip1)
+{
+    // inspect *(i+1) and decide if you want to erase it
+    // ...
+    if (I want to erase *(i+1))
+        i = fl.erase_after(i);
+    else
+        ++i;
+    ip1 = i;
+}
+
      
+
      
+In the above example code, it is convenient if erase_after returns
+the element prior to the erased element (range) instead of the element
+after the erase element (range).
+
      
+
      
+Existing practice:
+
      
+
        
+
      • SGI slist returns an iterator referencing the element after the erased range.
        • 
+
      • CodeWarrior slist returns an iterator referencing the element before the erased range.
        • 
+
      
+
      
+There is not a strong technical argument for either solution over the other.
+
      
 
      2. 
+
 
    2. 
-Drop the copy-constructible overload entirely and rely on perfect
-forwarding to catch move issues one level deeper.
+
      
+With all other containers, operations always work on the range
+[first, last) and/or prior to the given position.
+
      
+
      
+With forward_list, operations sometimes work on the range
+(first, last] and/or after the given position.
+
      
+
      
+This is simply due to the fact that in order to operate on
+*first (with forward_list) one needs access to
+*(first-1).  And that's not practical with
+forward_list.  So the operating range needs to start with (first,
+not [first (as the current working paper says). 
+
      
+
      
+Additionally, if one is interested in  splicing the range (first, last),
+then (with forward_list), one needs practical (constant time) access to
+*(last-1) so that one can set the next field in this node to
+the proper value.  As this is not possible with forward_list, one must
+specify the last element of interest instead of one past the last element of
+interest.  The syntax for doing this is to pass (first, last] instead
+of (first, last).
+
      
+
      
+With erase_after we have a choice of either erasing the range
+(first, last] or (first, last).  Choosing the latter
+enables:
+
      
+
      x.erase_after(pos, x.end());
+
      
+
+
      
+With the former, the above statement is inconvenient or expensive due to the lack
+of constant time access to x.end()-1.  However we could introduce:
+
      
+
+
      iterator erase_to_end(const_iterator position);
+
      
+
+
      
+to compensate.
+
      
+
+
      
+The advantage of the former ((first, last]) for erase_after
+is a consistency with splice_after which uses (first, last]
+as the specified range.  But this either requires the addition of erase_to_end
+or giving up such functionality.
+
      
+
 
      3. 
+
 
    3. 
-This is a fundamental problem in move-syntax that relies on the
-presence of two overloads, and we need to look more deeply into this
-area as a whole - do not solve this issue in isolation.
+As stated in the discussion of 892, and reienforced by point 2 above,
+a splice_after should work on the source range (first, last]
+if the operation is to be Ο(1).  When splicing an entire list x the
+algorithm needs (x.before_begin(), x.end()-1].  Unfortunately x.end()-1
+is not available in constant time unless we specify that it must be.  In order to
+make x.end()-1 available in constant time, the implementation would have
+to dedicate a pointer to it.  I believe the design of
+N2543
+intended a nominal overhead of foward_list of 1 pointer.  Thus splicing
+one entire forward_list into another can not be Ο(1).
 
      4. 
 
    
 
 
    [
-Post Summit, Alisdair adds:
+Batavia (2009-05):
 ]
    
 
-
 
    
 
    
-Both comment and issue have been resolved by the adoption of
-N2844
-(rvalue references safety fix) at the last meeting.
+We agree with the proposed resolution.
 
    
-
 
    
-Suggest resolve as NAD Editorial with a reference to the paper.
+Move to Review.
 
    
 
    
 
 
    [
-Batavia (2009-05):
+2009-07 Frankfurt
 ]
    
 
-
    
-We agree that this has been resolved in the latest Working Draft.
-Move to NAD.
-
    
-
 
-
    Proposed resolution:
    
+
    
 
    
-Recommend NAD, addressed by N2844.
+We may need a new issue to correct splice_after, because it may no
+longer be correct to accept an rvalues as an argument. Merge may be
+affected, too. This might be issue 1133. (Howard: confirmed)
 
    
+
    
+Move this to Ready, but the Requires clause of the second form of
+splice_after should say "(first, last)," not "(first, last]" (there are
+three occurrences). There was considerable discussion on this. (Howard: fixed)
+
    
+
    
+Alan suggested removing the "foward_last<T. Alloc>&& x"
+parameter from the second form of splice_after, because it is redundant.
+PJP wanted to keep it, because it allows him to check for bad ranges
+(i.e. "Granny knots").
+
    
+
    
+We prefer to keep x.
+
    
+
    
+Beman. Whenever we deviate from the customary half-open range in the
+specification, we should add a non-normative comment to the standard
+explaining the deviation. This clarifies the intention and spares the
+committee much confusion in the future.
+
    
+
    
+Alan to write a non-normative comment to explain the use of fully-closed ranges.
+
    
+
    
+Move to Ready, with the changes described above. (Howard: awaiting note from Alan)
+
    
+
    
 
+
    [
+2009-10 Santa Cruz:
+]
    
 
 
+
    
+NAD Editorial, addressed by
+N2988.
+
    
 
 
-
    
-
    902. Regular is the wrong concept to constrain numeric_limits
    
-
    Section: 18.3.1 [limits] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2008-09-24  Last modified: 2009-07-16
    
-
    View all other issues in [limits].
    
-
    View all issues with NAD Concepts status.
    
-
    Discussion:
    
-
-
    Addresses FR 32 and DE 16
    
 
+
    Proposed resolution:
    
 
    
-numeric_limits has functions specifically designed to return NaNs, which
-break the model of Regular (via its axioms.)  While floating point types
-will be acceptible in many algorithms taking Regular values, it is not
-appopriate for this specific API and we need a less refined constraint.
+Wording below assumes issue 878 is accepted, but this issue is
+independent of that issue.
+
    
+
+
    
+Change 23.3.3.4 [forwardlist.modifiers]:
+
    
+
+
    
+
    iterator erase_after(const_iterator position);
+
    
+
    
+
    
+Requires: The iterator following position is dereferenceable.
+
    
+
    
+Effects: Erases the element pointed to by the iterator following position.
+
    
+
    
+Returns: An iterator pointing to the element following the one that was erased, or end() if no such 
+element exists
+An iterator equal to position.
+
    
+
    
+
+
+
    iterator erase_after(const_iterator position, const_iterator last);
+
    
+
    
+
    
+Requires: All iterators in the range
+[(position,last)
+are dereferenceable.
+
    
+
    
+Effects: Erases the elements in the range
+[(position,last).
+
    
+
    
+Returns:  An iterator equal to position last
+
    
+
    
+
    
+
+
    
+Change 23.3.3.5 [forwardlist.ops]:
+
    
+
+
    
+
    void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
+
    
+
    
+
    
+Requires: position is before_begin() or a
+dereferenceable iterator in the range [begin(), end)). &x != this.
+
    
+
    
+Effects: Inserts the contents of x after position, and
+x becomes empty. Pointers and references to 
+the moved elements of x now refer to those same elements but as members of *this.
+Iterators referring to the moved elements will continue to refer to their elements,
+but they now behave as iterators into *this, not into x. 
+
    
+
    
+Throws: Nothing. 
+
    
+
    
+Complexity: Ο(1) Ο(distance(x.begin(), x.end()))
+
    
+
    
+
+
    ...
    
+
+
    void splice_after(const_iterator position, forward_list<T,Allocator>&& x, 
+                  const_iterator first, const_iterator last);
+
    
+
    
+
    
+Requires: position is before_begin() or a
+dereferenceable iterator in the range [begin(), end)).
+(first,last) is a valid range in
+x, and all iterators in the range
+(first,last) are dereferenceable.
+position is not an iterator in the range (first,last).
+
    
+
    
+Effects: Inserts elements in the range (first,last)
+after position and removes the elements from x.
+Pointers and references to the moved elements of x now refer to
+those same elements but as members of *this. Iterators
+referring to the moved elements will continue to refer to their
+elements, but they now behave as iterators into *this, not into
+x.
+
    
+
    
+Complexity: Ο(1).
+
    
+
    
+
+
    
+
+
+
+
+
+
+
    
+
    901. insert iterators can move from lvalues
    
+
    Section: 24.5.2.5 [insert.iterator] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2008-09-24  Last modified: 2009-07-13
    
+
    View all issues with NAD status.
    
+
    Discussion:
    
+
    Addresses UK 282
    
+
+
    
+The requires clause on the const T & overloads in
+back_insert_iterator/front_insert_iterator/insert_iterator mean that the
+assignment operator will implicitly move from lvalues of a move-only type.
+
    
+
    
+Suggested resolutions are:
+
    
+
      
+
    1. 
+Add another overload with a negative constraint on copy-constructible
+and flag it "= delete".
+
      2. 
+
    2. 
+Drop the copy-constructible overload entirely and rely on perfect
+forwarding to catch move issues one level deeper.
+
      3. 
+
    3. 
+This is a fundamental problem in move-syntax that relies on the
+presence of two overloads, and we need to look more deeply into this
+area as a whole - do not solve this issue in isolation.
+
      4. 
+
    
+
+
    [
+Post Summit, Alisdair adds:
+]
    
+
+
+
    
+
    
+Both comment and issue have been resolved by the adoption of
+N2844
+(rvalue references safety fix) at the last meeting.
+
    
+
+
    
+Suggest resolve as NAD Editorial with a reference to the paper.
+
    
+
    
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+We agree that this has been resolved in the latest Working Draft.
+Move to NAD.
+
    
+
+
+
    Proposed resolution:
    
+
    
+Recommend NAD, addressed by N2844.
+
    
+
+
+
+
+
+
    
+
    902. Regular is the wrong concept to constrain numeric_limits
    
+
    Section: 18.3.1 [limits] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2008-09-24  Last modified: 2009-07-16
    
+
    View all other issues in [limits].
    
+
    View all issues with NAD Concepts status.
    
+
    Discussion:
    
+
+
    Addresses FR 32 and DE 16
    
+
+
    
+numeric_limits has functions specifically designed to return NaNs, which
+break the model of Regular (via its axioms.)  While floating point types
+will be acceptible in many algorithms taking Regular values, it is not
+appopriate for this specific API and we need a less refined constraint.
 
    
 
 
    FR 32:
    
@@ -22378,7 +25814,7 @@ treatment of axioms in clause 14.
 
 
    
 
    903. back_insert_iterator issue
    
-
    Section: 24.7.1 [back.insert.iterator] Status: NAD
+
    Section: 24.5.2.1 [back.insert.iterator] Status: NAD
  Submitter: Dave Abrahams Opened: 2008-09-19  Last modified: 2009-07-16
    
 
    View all issues with NAD status.
    
 
    Discussion:
    
@@ -22422,7 +25858,7 @@ Move to NAD.
 
 
      
 
    1. 
-If 1009 is accepted, OutputIterator does no longer support post increment.
+If 1009 is accepted, OutputIterator does no longer support post increment.
 
      2. 
 
    2. 
 To support backward compatibility a second overload of operator*
@@ -22446,7 +25882,6 @@ to properly reflect the dual nature of built-in operator* as of
 
      905. Mutex specification questions
      
 
      Section: 30.4.1.1 [thread.mutex.class] Status: Dup
  Submitter: Herb Sutter Opened: 2008-09-18  Last modified: 2009-03-22
      
-
      View other active issues in [thread.mutex.class].
      
 
      View all other issues in [thread.mutex.class].
      
 
      View all issues with Dup status.
      
 
      Duplicate of: 893
      
@@ -22662,9 +26097,97 @@ constraint "ValueType".
 
 
 
+
      
+
      908. Deleted assignment operators for atomic types must be volatile
      
+
      Section: 29.5 [atomics.types] Status: NAD Editorial
+ Submitter: Anthony Williams Opened: 2008-09-26  Last modified: 2009-10-26
      
+
      View all other issues in [atomics.types].
      
+
      View all issues with NAD Editorial status.
      
+
      Discussion:
      
+
+
      Addresses US 90
      
+
+
      
+The deleted copy-assignment operators for the atomic types are not
+marked as volatile in N2723, whereas the assignment operators from the
+associated non-atomic types are. e.g.
+
      
+
      atomic_bool& operator=(atomic_bool const&) = delete;
+atomic_bool& operator=(bool) volatile;
+
      
+
+
      
+This leads to ambiguity when assigning a non-atomic value to a
+non-volatile instance of an atomic type:
+
      
+
      atomic_bool b;
+b=false;
+
      
+
+
      
+Both assignment operators require a standard conversions: the
+copy-assignment operator can use the implicit atomic_bool(bool)
+conversion constructor to convert false to an instance of
+atomic_bool, or b can undergo a qualification conversion in order to
+use the assignment from a plain bool.
+
      
+
+
      
+This is only a problem once issue 845 is applied.
+
      
+
+
      [
+Summit:
+]
      
+
+
      
+Move to open. Assign to Lawrence. Related to US 90 comment.
+
      
+
+
      [
+2009-08-17 Handled by
+N2925.
+]
      
+
+
+
      [
+2009-10 Santa Cruz:
+]
      
+
+
+
      
+NAD Editorial.  Solved by
+N2992.
+
      
+
+
+
+
      Proposed resolution:
      
+
      
+Add volatile qualification to the deleted copy-assignment operator of
+all the atomic types:
+
      
+
+
      atomic_bool& operator=(atomic_bool const&) volatile = delete;
+atomic_itype& operator=(atomic_itype const&) volatile = delete;
+
      
+
+
      
+etc.
+
      
+
      
+This will mean that the deleted copy-assignment operator will require
+two conversions in the above example, and thus be a worse match than
+the assignment from plain bool.
+
      
+
+
+
+
+
 
      
 
      912. Array swap needs to be conceptualized
      
-
      Section: 25.4.3 [alg.swap] Status: NAD Concepts
+
      Section: 25.3.3 [alg.swap] Status: NAD Concepts
  Submitter: Daniel Krügler Opened: 2008-10-01  Last modified: 2009-07-13
      
 
      View all other issues in [alg.swap].
      
 
      View all issues with NAD Concepts status.
      
@@ -22695,7 +26218,7 @@ Move to NAD; the changes have already been made.
 
 
      Proposed resolution:
      
 
      
-Replace in 25.4.3 [alg.swap] before p. 3 until p. 4 by
+Replace in 25.3.3 [alg.swap] before p. 3 until p. 4 by
 
      
 
 
      template <class ValueType T, size_t N>
@@ -22719,13 +26242,13 @@ void swap(T (&a)[N], T (&b)[N]);
 
 
      
 
      913. Superfluous requirements for replace algorithms
      
-
      Section: 25.4.5 [alg.replace] Status: NAD Concepts
+
      Section: 25.3.5 [alg.replace] Status: NAD Concepts
  Submitter: Daniel Krügler Opened: 2008-10-03  Last modified: 2009-07-14
      
 
      View all other issues in [alg.replace].
      
 
      View all issues with NAD Concepts status.
      
 
      Discussion:
      
 
      
-(A) 25.4.5 [alg.replace]/1:
+(A) 25.3.5 [alg.replace]/1:
 
      
 
 
      
@@ -22733,7 +26256,7 @@ void swap(T (&a)[N], T (&b)[N]);
 
      
 
 
      
-(B) 25.4.5 [alg.replace]/4:
+(B) 25.3.5 [alg.replace]/4:
 
      
 
 
      
@@ -22780,7 +26303,7 @@ Move to Tentatively Ready.
 
        
 
      1. 
 
        
-Remove 25.4.5 [alg.replace]/1.
+Remove 25.3.5 [alg.replace]/1.
 
        
 
        template<ForwardIterator Iter, class T> 
   requires OutputIterator<Iter, Iter::reference> 
@@ -22803,7 +26326,7 @@ template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred,
 
        2. 
 
      2. 
 
        
-25.4.5 [alg.replace]/4: Remove the sentence "The results of the
+25.3.5 [alg.replace]/4: Remove the sentence "The results of the
 expressions *first and
 new_value shall be writable to the result output iterator.".
 
        
@@ -22840,13 +26363,13 @@ iterator. The ranges [first,last) and [result,result +
 
 
        
 
        914. Superfluous requirement for unique
        
-
        Section: 25.4.9 [alg.unique] Status: NAD Concepts
+
        Section: 25.3.9 [alg.unique] Status: NAD Concepts
  Submitter: Daniel Krügler Opened: 2008-10-03  Last modified: 2009-07-14
        
 
        View all other issues in [alg.unique].
        
 
        View all issues with NAD Concepts status.
        
 
        Discussion:
        
 
        
-25.4.9 [alg.unique]/2: "Requires: The comparison function shall be an
+25.3.9 [alg.unique]/2: "Requires: The comparison function shall be an
 equivalence relation."
 
        
 
@@ -22873,7 +26396,7 @@ Move to Tentatively Ready.
 
 
        Proposed resolution:
        
 
        
-Remove 25.4.9 [alg.unique]/2
+Remove 25.3.9 [alg.unique]/2
 
        
 
 
        template<ForwardIterator Iter>
@@ -22902,119 +26425,244 @@ template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type&
 
 
 
        
-
        918. Swap for tuple needs to be conceptualized
        
-
        Section: 20.5.2.6 [tuple.swap] Status: NAD Concepts
- Submitter: Daniel Krügler Opened: 2008-10-04  Last modified: 2009-07-13
        
-
        View all issues with NAD Concepts status.
        
+
        916. Redundant move-assignment operator of pair should be removed
        
+
        Section: 20.3.4 [pairs] Status: NAD
+ Submitter: Daniel Krügler Opened: 2008-10-04  Last modified: 2009-10-23
        
+
        View other active issues in [pairs].
        
+
        View all other issues in [pairs].
        
+
        View all issues with NAD status.
        
 
        Discussion:
        
+
        see also 917.
        
+
 
        
-Issue 522 was accepted after tuple had been conceptualized,
-therefore this step needs to be completed.
+The current WP provides the following assignment operators for pair
+in 20.3.4 [pairs]/1:
+
        
+
+
          
+
        1. 
+
          template<class U , class V>
+requires HasAssign<T1, const U&> && HasAssign<T2, const V&>
+pair& operator=(const pair<U , V>& p);
+
          
+
          2. 
+
        2. 
+
          requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
+
          
+
          3. 
+
        3. 
+
          template<class U , class V>
+requires HasAssign<T1, RvalueOf<U>::type> && HasAssign<T2, RvalueOf<V>::type>
+pair& operator=(pair<U , V>&& p);
+
          
+
          4. 
+
        
+
+
        
+It seems that the functionality of (2) is completely covered by (3), therefore
+(2) should be removed.
 
        
 
 
        [
-Post Summit Daniel adds
+Batavia (2009-05):
 ]
        
 
-
 
        
-This is now NAD Editorial (addressed by
-N2844)
-except for item 3 in the proposed wording.
+
        
+Bill believes the extra assignment operators are necessary for resolving
+ambiguities, but that does not mean it needs to be part of the specification.
+
        
+
        
+Move to Open.
+We recommend this be looked at in the context of the ongoing work
+related to the pair templates.
+
        
 
        
 
 
        [
-2009-05-01 Daniel adds:
+2009-07 Frankfurt:
 ]
        
 
 
 
        
-As of the recent WP
-(N2857),
-this issue is now completely covered by editorial
-changes (including the third bullet), therefore I unconditionally recommend
-NAD.
+Leave this open pending the removal of concepts from the WD.
 
        
 
 
        [
-Batavia (2009-05):
+2009-10 Santa Cruz:
 ]
        
 
+
 
        
-
        
-We observed that all the proposed changes have already been applied to the
-Working Draft, rendering this issue moot.
-
        
-
        
-Move to NAD.
-
        
+Mark as NAD, see issue 801.
 
        
 
 
 
 
        Proposed resolution:
        
-
          
+
            
 
          1. 
 
            
-In both 20.5.1 [tuple.general]/2 and 20.5.2.7 [tuple.special] change
+In 20.3.4 [pairs] p. 1, class pair and just before p. 13 remove the declaration:
 
            
 
-
            template <class Swappable... Types>
-void swap(tuple<Types...>& x, tuple<Types...>& y);
+
            requires MoveAssignable<T1> && MoveAssignable<T2> pair& operator=(pair&& p );
 
            
-
 
            2. 
 
 
          2. 
-
            
-In 20.5.2 [tuple.tuple], class tuple definition and in
-20.5.2.6 [tuple.swap], change
+Remove p.13+p.14
+
            3. 
+
+
          
+
+
+
+
+
+
          
+
          917. Redundant move-assignment operator of tuple should be removed
          
+
          Section: 20.5.2.1 [tuple.cnstr] Status: NAD
+ Submitter: Daniel Krügler Opened: 2008-10-04  Last modified: 2009-10-23
          
+
          View all other issues in [tuple.cnstr].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
          see also 916.
          
+
          
+N2770 (and thus now the WP) removed the
+non-template move-assignment operator from tuple's class definition,
+but the latter individual member description does still provide this
+operator. Is this (a) an oversight and can it (b) be solved as part of an
+editorial process?
 
          
 
-
          requires Swappable<Types>...void swap(tuple&);
-
          
+
          [
+Post Summit Daniel provided wording.
+]
          
 
-
 
-
        1. 
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We believe that the proposed resolution's part 1 is editorial.
+
          
+
          
+Regarding part 2, we either remove the specification as proposed,
+or else add back the declaration to which the specification refers.
+Alisdair and Bill prefer the latter.
+It is not immediately obvious whether the function is intended to be present.
+
          
+
          
+We recommend that the Project Editor restore the missing declaration
+and that we keep part 2 of the issue alive.
+
          
 
          
-In 20.5.2.6 [tuple.swap] remove the current requires-clause, which says:
+Move to Open.
 
          
+
          
+
+
          [
+2009-07 Frankfurt:
+]
          
+
 
 
          
-Requires: Each type in Types shall be Swappable
+Leave this open pending the removal of concepts from the WD.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD, see issue 801.
 
          
+
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+In 20.5.2 [tuple.tuple], class tuple just before member swap please
+change as indicated:
+
            
+
            [
+This fixes an editorial loss between N2798 to N2800
+]
            
+
+
            template <class... UTypes>
+requires HasAssign<Types, const UTypes&>...
+tuple& operator=(const pair<UTypes...>&);
+
+template <class... UTypes>
+requires HasAssign<Types, RvalueOf<UTypes>::type>...
+tuple& operator=(pair<UTypes...>&&);
+
            
 
            2. 
+
          2. 
+
            
+In 20.5.2.1 [tuple.cnstr], starting just before p. 11 please remove
+as indicated:
+
            
 
+
            requires MoveAssignable<Types>... tuple& operator=(tuple&& u);
+
            
+
            
+
            
+-11- Effects: Move-assigns each element of u to the corresponding
+element of *this.
+
            
+
            
+-12- Returns: *this.
+
            
+
            
+
            
+
            3. 
 
          
 
 
 
 
 
-
 
          
-
          927. Dereferenceable  should be HasDereference
          
-
          Section: 20.8.2.2 [allocator.concepts] Status: NAD Concepts
- Submitter: Pablo Halpern Opened: 2008-10-23  Last modified: 2009-07-13
          
+
          918. Swap for tuple needs to be conceptualized
          
+
          Section: 20.5.2.3 [tuple.swap] Status: NAD Concepts
+ Submitter: Daniel Krügler Opened: 2008-10-04  Last modified: 2009-07-13
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
 
          
-20.8.2.2 [allocator.concepts] contains a reference to a concept named
-Dereferenceable. No such concept exists.
+Issue 522 was accepted after tuple had been conceptualized,
+therefore this step needs to be completed.
 
          
 
 
          [
-Daniel adds 2009-02-14:
+Post Summit Daniel adds
 ]
          
 
 
 
          
-The proposal given in the paper
-N2829
-would automatically resolve this issue.
+This is now NAD Editorial (addressed by
+N2844)
+except for item 3 in the proposed wording.
 
          
 
+
          [
+2009-05-01 Daniel adds:
+]
          
+
+
+
          
+As of the recent WP
+(N2857),
+this issue is now completely covered by editorial
+changes (including the third bullet), therefore I unconditionally recommend
+NAD.
+
          
 
 
          [
 Batavia (2009-05):
@@ -23022,263 +26670,346 @@ Batavia (2009-05):
 
 
          
 
          
-This particular set of changes has already been made.
-There are two related changes later on (and possibly also an earlier Example);
-these can be handled editorially.
+We observed that all the proposed changes have already been applied to the
+Working Draft, rendering this issue moot.
 
          
 
          
-Move to NAD Editorial.
+Move to NAD.
 
          
 
          
 
 
+
 
          Proposed resolution:
          
+
            
+
          1. 
 
            
-Change all uses of the concept Dereferenceable to
-HasDereference in 20.8.2.2 [allocator.concepts].
+In both 20.5.1 [tuple.general]/2 and 20.5.2.9 [tuple.special] change
 
            
 
+
            template <class Swappable... Types>
+void swap(tuple<Types...>& x, tuple<Types...>& y);
+
            
 
+
            2. 
 
-
-
-
            
-
            928. Wrong concepts used for tuple's comparison operators
            
-
            Section: 20.5.2.5 [tuple.rel] Status: NAD Concepts
- Submitter: Joe Gottman Opened: 2008-10-28  Last modified: 2009-07-13
            
-
            View all other issues in [tuple.rel].
            
-
            View all issues with NAD Concepts status.
            
-
            Discussion:
            
+
          2. 
 
            
-In the latest working draft for C++0x, tuple's operator== and operator<
-are declared as 
+In 20.5.2 [tuple.tuple], class tuple definition and in
+20.5.2.3 [tuple.swap], change
 
            
 
-
            template<class... TTypes, class... UTypes> 
-  requires EqualityComparable<TTypes, UTypes>... 
-  bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
            requires Swappable<Types>...void swap(tuple&);
 
            
 
+
            3. 
+
+
          3. 
 
            
-and
+In 20.5.2.3 [tuple.swap] remove the current requires-clause, which says:
 
            
 
-
            template<class... TTypes, class... UTypes> 
-  requires LessThanComparable<TTypes, UTypes>... 
-  bool operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
-
            
+
            
+Requires: Each type in Types shall be Swappable
+
            
+
            4. 
+
+
          
 
+
+
+
+
+
+
          
+
          919. (forward_)list specialized remove algorithms are over constrained
          
+
          Section: 23.3.3.5 [forwardlist.ops], 23.3.4.4 [list.ops] Status: NAD
+ Submitter: Daniel Krügler Opened: 2008-10-06  Last modified: 2009-10-23
          
+
          View all other issues in [forwardlist.ops].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
 
          
-But the concepts EqualityComparable and LessThanComparable only take one 
-parameter, not two.  Also, even if LessThanComparable could take two 
-parameters, the definition of tuple::operator<() should also require 
+The signatures of forwardlist::remove and list::remove
+defined in 23.3.3.5 [forwardlist.ops] before 11 + 23.3.4.4 [list.ops] before 15:
 
          
 
-
          LessThanComparable<UTypes, TTypes>... // (note the order) 
+
          requires EqualityComparable<T> void remove(const T& value);
 
          
 
 
          
-since the algorithm for tuple::operator< is the following (pseudo-code)
+are asymmetric to their predicate variants (which only require
+Predicate, not EquivalenceRelation) and with the free algorithm
+remove (which only require HasEqualTo). Also, nothing in the
+pre-concept WP
+N2723
+implies that EqualityComparable should
+be the intended requirement.
 
          
 
-
          for (size_t N = 0; N < sizeof...(TTypes); ++N) { 
-    if (get<N>(t) < get<N>(u) return true; 
-    else if ((get<N>(u) < get<N>(t)) return false; 
-} 
-
-return false; 
-
          
+
          [
+Batavia (2009-05):
+]
          
 
+
          
 
          
-Similar problems hold for tuples's other comparison operators.
+We agree with the proposed resolution,
+but would like additional input from concepts experts.
+
          
+
          
+Move to Review.
 
          
+
          
 
 
          [
-Post Summit:
+2009-07-21 Alisdair adds:
 ]
          
 
 
 
          
-Recommend Tentatively Ready.
+Current rationale and wording for this issue is built around concepts. I
+suggest the issue reverts to Open status. I believe there is enough of
+an issue to review after concepts are removed from the WP to re-examine
+the issue in Santa Cruz, rather than resolve as NAD Concepts.
 
          
 
+
          [
+2009-10-10 Daniel adds:
+]
          
 
 
-
          Proposed resolution:
          
-
          
-In 20.5.1 [tuple.general] and 20.5.2.5 [tuple.rel] change:
-
          
+
          
+Recommend NAD: The concept-free wording as of
+N2960
+has no longer the
+over-specified requirement
+EqualityComparable for the remove function that uses ==. In fact, now
+the same test conditions exists
+as for the free algorithm remove (25.3.8 [alg.remove]). The error was
+introduced in the process of conceptifying.
+
          
 
-
          template<class... TTypes, class... UTypes>
-  requires EqualityComparableHasEqualTo<TTypes, UTypes>...
-  bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
          [
+2009-10 Santa Cruz:
+]
          
 
-template<class... TTypes, class... UTypes>
-  requires LessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>...
-  bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
 
-template<class... TTypes, class... UTypes>
-  requires EqualityComparableHasEqualTo<TTypes, UTypes>...
-  bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
          
+NAD, solved by the removal of concepts.
+
          
 
-template<class... TTypes, class... UTypes>
-  requires LessThanComparableHasLess<UTTypes, TUTypes>... && HasLess<UTypes, TTypes>...
-  bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
 
-template<class... TTypes, class... UTypes>
-  requires LessThanComparableHasLess<UTTypes, TUTypes>... && HasLess<UTypes, TTypes>...
-  bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
 
-template<class... TTypes, class... UTypes>
-  requires LessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>...
-  bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+Replace in 23.3.3.5 [forwardlist.ops] before 11 and in 23.3.4.4 [list.ops] before 15
+
            
+
+
            requires EqualityComparable<T> HasEqualTo<T, T> void remove(const T& value);
 
            
+
            2. 
+
          
+
 
 
 
 
 
 
          
-
          937. Atomics for standard typedef types
          
+
          923. atomics with floating-point 
          
 
          Section: 29 [atomics] Status: NAD Editorial
- Submitter: Clark Nelson Opened: 2008-12-05  Last modified: 2009-05-23
          
-
          View other active issues in [atomics].
          
+ Submitter: Herb Sutter Opened: 2008-10-17  Last modified: 2009-10-26
          
 
          View all other issues in [atomics].
          
 
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
-
          Addresses US 89
          
-
-
          
 
          
-The types in the table "Atomics for standard typedef types" should be
-typedefs, not classes. These semantics are necessary for compatibility
-with C.
+Right now, C++0x doesn't have atomic<float>. We're thinking of adding
+the words to support it for TR2 (note: that would be slightly
+post-C++0x). If we need it, we could probably add the words.
 
          
+
          
+Proposed resolutions: Using atomic<FP>::compare_exchange (weak or
+strong) should be either:
+
          
+
+
            
+
          1. 
+ill-formed, or
+
            2. 
+
          2. 
+well-defined.
+
            3. 
+
          
 
 
          
-Change the classes to typedefs.
+I propose Option 1 for C++0x for expediency. If someone wants to argue
+for Option 2, they need to say what exactly they want compare_exchange
+to mean in this case (IIRC, C++0x doesn't even assume IEEE 754).
 
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+Move to open. Blocked until concepts for atomics are addressed.
 
          
 
+
          [
+Post Summit Anthony adds:
+]
          
+
+
+
          
 
          
-N2427
-specified different requirements for atomic analogs of fundamental
-integer types (such as atomic_int) and for atomic analogs of <cstdint>
-typedefs (such as atomic_size_t). Specifically, atomic_int et al. were
-specified to be distinct classes, whereas atomic_size_t et al. were
-specified to be typedefs. Unfortunately, in applying
-N2427
-to the WD, that distinction was erased, and the atomic analog of every <cstdint>
-typedef is required to be a distinct class.
+Recommend NAD. C++0x does have std::atomic<float>, and both
+compare_exchange_weak and compare_exchange_strong are well-defined in
+this case. Maybe change the note in 29.6 [atomics.types.operations] paragraph 20 to:
 
          
 
+
          
 
          
-It shouldn't be required that the atomic analog of every <cstdint>
-typedef be a typedef for some fundamental integer type. After all,
-<cstdint> is supposed to provide standard names for extended integer
-types. So there was a problem in
-N2427,
-which certainly could have been
-interpreted to require that. But the status quo in the WD is even worse,
-because it's unambiguously wrong.
+[Note: The effect of the compare-and-exchange operations is
 
          
+
          if (!memcmp(object,expected,sizeof(*object)))
+    *object = desired;
+else
+    *expected = *object;
+
          
 
 
          
-What is needed are words to require the existence of a bunch of type
-names, without specifying whether they are class names or typedef names.
+This may result in failed comparisons for values that compare equal if
+the underlying type has padding bits or alternate representations of
+the same value. -- end note]
 
          
+
          
+
+
          
 
 
          [
-Summit:
+2009-10 Santa Cruz:
 ]
          
 
 
 
          
-
          
-Change status to NAD, editorial. See US 89 comment notes above.
-
          
-
          
-Direct the editor to turn the types into typedefs as proposed in the
-comment. Paper approved by committee used typedefs, this appears to have
-been introduced as an editorial change. Rationale: for compatibility
-with C.
-
          
+NAD Editorial.  Solved by
+N2992.
 
          
 
 
+
 
          Proposed resolution:
          
 
          
+Change the note in 29.6 [atomics.types.operations] paragraph 20 to:
+
          
+
+
          
+
          
+[Note: The effect of the compare-and-exchange operations is
+
          
+
          if (*object == *expected !memcmp(object,expected,sizeof(*object)))
+    *object = desired;
+else
+    *expected = *object;
+
          
+
+
          
+This may result in failed comparisons for values that compare equal if
+the underlying type has padding bits or alternate representations of
+the same value. -- end note]
 
          
+
          
+
 
 
 
 
 
 
          
-
          941. Ref-qualifiers for assignment operators
          
-
          Section: 17 [library] Status: NAD
- Submitter: Niels Dekker Opened: 2008-12-18  Last modified: 2009-07-17
          
-
          View other active issues in [library].
          
-
          View all other issues in [library].
          
-
          View all issues with NAD status.
          
+
          924. structs with internal padding
          
+
          Section: 29 [atomics] Status: NAD Editorial
+ Submitter: Herb Sutter Opened: 2008-10-17  Last modified: 2009-10-26
          
+
          View all other issues in [atomics].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
 
          
-The assignment and equality operators = and == are easily confused, just
-because of their visual similarity, and in this case a simple typo can cause
-a serious bug. When the left side of an operator= is an rvalue, it's
-highly unlikely that the assignment was intended by the programmer:
+Right now, the compare_exchange_weak loop should rapidly converge on the
+padding contents. But compare_exchange_strong will require a bit more
+compiler work to ignore padding for comparison purposes.
 
          
-
          if ( func() = value )  // Typical typo: == intended!
-
          
 
          
-Built-in types don't support assignment to an rvalue, but unfortunately,
-a lot of types provided by the Standard Library do.
+Note that this isn't a problem for structs with no padding, and we do
+already have one portable way to ensure that there is no padding that
+covers the key use cases: Have elements be the same type. I suspect that
+the greatest need is for a structure of two pointers, which has no
+padding problem. I suspect the second need is a structure of a pointer
+and some form of an integer. If that integer is intptr_t, there will be
+no padding.
 
          
 
          
-Fortunately the language now offers a syntax to prevent a certain member
-function from having an rvalue as *this: by adding a ref-qualifier (&)
-to the member function declaration.  Assignment operators are explicitly
-mentioned as a use case of ref-qualifiers, in "Extending Move Semantics
-To *this (Revision 1)",
-N1821 by Daveed
-Vandevoorde and Bronek Kozicki
+Related but separable issue: For unused bitfields, or other unused
+fields for that matter, we should probably say it's the programmer's
+responsibility to set them to zero or otherwise ensure they'll be
+ignored by memcmp.
 
          
+
 
          
-Hereby I would like to propose adding ref-qualifiers to all appropriate
-assignment operators in the library.
+Proposed resolutions: Using
+atomic<struct-with-padding>::compare_exchange_strong should be either:
+
          
+
+
            
+
          1. 
+ill-formed, or
+
            2. 
+
          2. 
+well-defined.
+
            3. 
+
          
+
+
          
+I propose Option 1 for C++0x for expediency, though I'm not sure how to
+say it. I would be happy with Option 2, which I believe would mean that
+compare_exchange_strong would be implemented to avoid comparing padding
+bytes, or something equivalent such as always zeroing out padding when
+loading/storing/comparing. (Either implementation might require compiler
+support.)
 
          
 
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+
 
          
-Move to Open.
-We recommend this be deferred until after the next Committee Draft.
+Move to open. Blocked until concepts for atomics are addressed.
 
          
 
 
          [
-Frankfurt 2009-07:
+Post Summit Anthony adds:
 ]
          
 
 
 
          
-
          
-The LWG declined to move forward with
-N2819.
-
          
-
          
-Moved to NAD.
-
          
+The resoultion of LWG 923 should resolve this issue as well.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2992.
 
          
 
 
+
 
          Proposed resolution:
          
 
          
-A proposed resolution is provided by the paper on this subject,
-N2819,
-Ref-qualifiers for assignment operators of the Standard Library
 
          
 
 
@@ -23286,121 +27017,191 @@ A proposed resolution is provided by the paper on this subject,
 
 
 
          
-
          942. Atomics synopsis typo
          
-
          Section: 29 [atomics] Status: Dup
- Submitter: Holger Grund Opened: 2008-12-19  Last modified: 2009-03-22
          
-
          View other active issues in [atomics].
          
-
          View all other issues in [atomics].
          
-
          View all issues with Dup status.
          
-
          Duplicate of: 880
          
+
          926. Sequentially consistent fences, relaxed operations and modification order
          
+
          Section: 29.3 [atomics.order] Status: NAD Editorial
+ Submitter: Anthony Williams Opened: 2008-10-19  Last modified: 2009-10-26
          
+
          View all other issues in [atomics.order].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
+
          Addresses UK 313
          
+
+
          
+There was an interesting issue raised over on comp.programming.threads
+today regarding the following example
+
          
 
+
          // Thread 1:
+x.store(1, memory_order_relaxed);           // SX
+atomic_thread_fence(memory_order_seq_cst);  // F1
+y.store(1, memory_order_relaxed);           // SY1
+atomic_thread_fence(memory_order_seq_cst);  // F2
+r1 = y.load(memory_order_relaxed);          // RY
 
+// Thread 2:
+y.store(0, memory_order_relaxed);          // SY2
+atomic_thread_fence(memory_order_seq_cst); // F3
+r2 = x.load(memory_order_relaxed);         // RX
+
          
 
 
          
-I'm looking at 29 [atomics] and can't really make sense of a couple of things.
+is the outcome r1 == 0 and r2 == 0 possible?
 
          
 
          
-Firstly, there appears to be a typo in the <cstdatomic> synopsis:
+I think the intent is that this is not possible, but I am not sure the
+wording guarantees that. Here is my analysis:
 
          
-
-
          
 
          
-The atomic_exchange overload taking an atomic_address
-is missing the second parameter:
+Since all the fences are SC, there must be a total order between them.
+F1 must be before F2 in that order since they are in
+the same thread. Therefore F3 is either before F1,
+between F1 and F2 or after F2.
 
          
-
-
          void* atomic_exchange(volatile atomic_address*);
-
          
-
 
          
-should be
+If F3 is after F2, then we can apply 29.3 [atomics.order]p5 from
+N2798:
 
          
 
-
          void* atomic_exchange(volatile atomic_address*, void*);
-
          
+
          
+For atomic operations A and B on an atomic object
+M, where A modifies M and B takes
+its value, if there are memory_order_seq_cst fences X
+and Y such that A is sequenced before X,
+Y is sequenced before B, and X precedes
+Y in S, then B observes either the effects of
+A or a later modification of M in its modification
+order.
+
          
 
 
          
-Note, that this is not covered by 880 "Missing atomic exchange parameter",
-which only talks about the atomic_bool.
+In this case, A is SX, B is RX, the
+fence X is F2 and the fence Y is F3,
+so RX must see 1.
 
          
-
          
-
-
-
-
          Proposed resolution:
          
 
          
-Change the synopsis in 29 [atomics]/2:
+If F3 is before F2, this doesn't apply, but
+F3 can therefore be before or after F1.
 
          
-
-
          void* atomic_exchange(volatile atomic_address*, void*);
-
          
-
-
-
-
-
-
-
          
-
          945. system_clock::rep not specified
          
-
          Section: 20.9.5.1 [time.clock.system] Status: NAD Editorial
- Submitter: Pete Becker Opened: 2008-12-19  Last modified: 2009-07-13
          
-
          View all other issues in [time.clock.system].
          
-
          View all issues with NAD Editorial status.
          
-
          Discussion:
          
 
          
-In 20.9.5.1 [time.clock.system], the declaration of system_clock::rep says "see
-below", but there is nothing below that describes it.
+If F3 is after F1, the same logic applies, but this
+time the fence X is F1. Therefore again, RX
+must see 1.
+
          
+
          
+Finally we have the case that F3 is before F1
+in the SC ordering. There are now no guarantees about RX, and
+RX can see r2==0.
+
          
+
          
+We can apply 29.3 [atomics.order]p5 again. This time,
+A is SY2, B is RY, X is
+F3 and Y is F1. Thus RY must observe
+the effects of SY2 or a later modification of y in its
+modification order.
+
          
+
          
+Since SY1 is sequenced before RY, RY must
+observe the effects of SY1 or a later modification of
+y in its modification order.
+
          
+
          
+In order to ensure that RY sees (r1==1), we must see
+that SY1 is later in the modification order of y than
+SY2.
+
          
+
          
+We're now skating on thin ice. Conceptually, SY2 happens-before
+F3, F3 is SC-ordered before F1, F1
+happens-before SY1, so SY1 is later in the
+modification order M of y, and RY must see
+the result of SY1 (r1==1). However, I don't think the
+words are clear on that.
 
          
 
 
          [
-Howard adds:
+Post Summit Hans adds:
 ]
          
 
 
 
          
 
          
-This note refers to:
+In my (Hans') view, our definition of fences will always be weaker than
+what particular hardware will guarantee.  Memory_order_seq_cst fences
+inherently don't guarantee sequential consistency anyway, for good
+reasons (e.g. because they can't enforce a total order on stores).
+ Hence I don't think the issue demonstrates a gross failure to achieve
+what we intended to achieve.  The example in question is a bit esoteric.
+ Hence, in my view, living with the status quo certainly wouldn't be a
+disaster either.
+
          
+
          
+In any case, we should probably add text along the lines of the
+following between p5 and p6 in 29.3 [atomics.order]:
 
          
-
 
          
--2- system_clock::duration::min() < system_clock::duration::zero() shall be true.
+[Note: Memory_order_seq_cst only ensures sequential consistency for a
+data-race-free program that uses exclusively memory_order_seq_cst
+operations.  Any use of weaker ordering will invalidate this guarantee
+unless extreme care is used.  In particular, memory_order_seq_cst fences
+only ensure a total order for the fences themselves.  They cannot, in
+general, be used to restore sequential consistency for atomic operations
+with weaker ordering specifications.]
 
          
 
 
          
-I.e. this is standardeze for "system_clock::rep is signed".
-Perhaps an editorial note along the lines of:
+Also see thread beginning at c++std-lib-23271.
 
          
 
-
          
--2- system_clock::duration::min() < system_clock::duration::zero()
-shall be true. [Note: system_clock::rep shall be signed. -- end note].
 
          
 
+
          [
+Herve's correction:
+]
          
+
+
          
 
          
-?
+Minor point, and sorry for the knee jerk reaction: I admit to having
+no knowledge of Memory_order_seq_cst, but my former boss (John Lakos)
+has ingrained an automatic introspection on the use of "only".   I
+think you meant:
 
          
 
+
          
+[Note: Memory_order_seq_cst ensures sequential consistency only
+for . . . .  In particular, memory_order_seq_cst fences ensure a
+total order only for . . .
+
          
+
          
+Unless, of course, Memory_order_seq_cst really do nothing but ensure
+sequential consistency for a data-race-free program that uses
+exclusively memory_order_seq_cst operations.
+
          
 
          
 
 
          [
-Batavia (2009-05):
+2009-10 Santa Cruz:
 ]
          
 
+
 
          
-We agree with the direction of the proposed resolution.
-Move to NAD Editorial.
+NAD Editorial.  Solved by
+N2992.
 
          
 
 
 
 
          Proposed resolution:
          
 
          
-Add a note to 20.9.5.1 [time.clock.system], p2:
+Add a new paragraph after 29.3 [atomics.order]p5 that says
 
          
+
 
          
--2- system_clock::duration::min() < system_clock::duration::zero()
-shall be true. [Note: system_clock::rep shall be signed. -- end note].
+For atomic operations A and B on an atomic object
+M, where A and B modify M, if there
+are memory_order_seq_cst fences X and Y such
+that A is sequenced before X, Y is sequenced
+before B, and X precedes Y in S,
+then B occurs later than A in the modifiction order of
+M.
 
          
 
 
@@ -23408,70 +27209,48 @@ shall be true. [Note: system_clock::rep shall be s
 
 
 
          
-
          946. duration_cast improperly specified
          
-
          Section: 20.9.3.7 [time.duration.cast] Status: NAD
- Submitter: Pete Becker Opened: 2008-12-20  Last modified: 2009-07-13
          
-
          View all other issues in [time.duration.cast].
          
-
          View all issues with NAD status.
          
+
          927. Dereferenceable  should be HasDereference
          
+
          Section: X [allocator.concepts] Status: NAD Concepts
+ Submitter: Pablo Halpern Opened: 2008-10-23  Last modified: 2009-07-13
          
+
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-20.9.3.7 [time.duration.cast]/3:
-
-
          
-.... All intermediate computations shall be
-carried out in the widest possible representation... .
-
          
-
-
          
-So ignoring
-floating-point types for the moment, all this arithmetic has to be done
-using the implementation's largest integral type, even if both arguments
-use int for their representation. This seems excessive. And it's not at
-all clear what this means if we don't ignore floating-point types.
-
          
-
 
          
-This issue is related to 952.
+X [allocator.concepts] contains a reference to a concept named
+Dereferenceable. No such concept exists.
 
          
 
 
          [
-Howard adds:
+Daniel adds 2009-02-14:
 ]
          
 
 
 
          
-
          
-The intent of this remark is that intermediate computations are carried out
-using:
-
          
-
-
          common_type<typename ToDuration::rep, Rep, intmax_t>::type
-
          
-
-
          
-The Remark was intended to be clarifying prose supporting the rather algorithmic description
-of the previous paragraph.  I'm open to suggestions.  Perhaps the entire paragraph
-3 (Remarks) would be better dropped?
-
          
+The proposal given in the paper
+N2829
+would automatically resolve this issue.
 
          
 
+
 
          [
 Batavia (2009-05):
 ]
          
 
 
          
 
          
-We view this as a specific case of issue 952,
-and should be resolved when that issue is resolved.
+This particular set of changes has already been made.
+There are two related changes later on (and possibly also an earlier Example);
+these can be handled editorially.
 
          
 
          
-Move to NAD.
+Move to NAD Editorial.
 
          
 
          
 
 
-
 
          Proposed resolution:
          
 
          
+Change all uses of the concept Dereferenceable to
+HasDereference in X [allocator.concepts].
 
          
 
 
@@ -23479,604 +27258,847 @@ Move to NAD.
 
 
 
          
-
          952. Various threading bugs #2
          
-
          Section: 20.9.3.7 [time.duration.cast] Status: NAD Editorial
- Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-07-13
          
-
          View all other issues in [time.duration.cast].
          
-
          View all issues with NAD Editorial status.
          
+
          928. Wrong concepts used for tuple's comparison operators
          
+
          Section: 20.5.2.7 [tuple.rel] Status: NAD Concepts
+ Submitter: Joe Gottman Opened: 2008-10-28  Last modified: 2009-07-13
          
+
          View all other issues in [tuple.rel].
          
+
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
 
          
-20.9.3.7 [time.duration.cast] specifies an implementation and imposes
-requirements in text (and the implementation doesn't satisfy all of the
-text requirements). Pick one.
+In the latest working draft for C++0x, tuple's operator== and operator<
+are declared as 
 
          
 
+
          template<class... TTypes, class... UTypes> 
+  requires EqualityComparable<TTypes, UTypes>... 
+  bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
          
+
 
          
-This issue is related to 946.
-
          
-
-
          [
-2009-05-10 Howard adds:
-]
          
-
-
-
          
-
          
-The Remarks paragraph is an English re-statement of the preceeding
-Returns clause.  It was meant to be clarifying and motivating, not
-confusing.  I'm not aware with how the Remarks contradicts the Returns clause
-but I'm ok with simply removing the Remarks.
+and
 
          
-
          
 
-
          [
-Batavia (2009-05):
-]
          
+
          template<class... TTypes, class... UTypes> 
+  requires LessThanComparable<TTypes, UTypes>... 
+  bool operator<(const tuple<TTypes...>& t, const tuple<UTypes...>& u);
+
          
 
-
          
 
          
-Pete suggests that this could be resolved
-by rephrasing the Remarks to Notes.
-
          
-
          
-Move to NAD Editorial.
+But the concepts EqualityComparable and LessThanComparable only take one 
+parameter, not two.  Also, even if LessThanComparable could take two 
+parameters, the definition of tuple::operator<() should also require 
 
          
-
          
 
+
          LessThanComparable<UTypes, TTypes>... // (note the order) 
+
          
 
-
          Proposed resolution:
          
 
          
+since the algorithm for tuple::operator< is the following (pseudo-code)
 
          
 
+
          for (size_t N = 0; N < sizeof...(TTypes); ++N) { 
+    if (get<N>(t) < get<N>(u) return true; 
+    else if ((get<N>(u) < get<N>(t)) return false; 
+} 
 
+return false; 
+
          
 
-
-
-
          
-
          969. What happened to Library Issue 475?
          
-
          Section: 25.3.4 [alg.foreach] Status: NAD Editorial
- Submitter: Stephan T. Lavavej Opened: 2009-01-12  Last modified: 2009-07-13
          
-
          View all other issues in [alg.foreach].
          
-
          View all issues with NAD Editorial status.
          
-
          Discussion:
          
 
          
-Library Issue 475 has CD1 status, but the non-normative note in
-N2723
-was removed in
-N2798
-(25.3.4 [alg.foreach] in both drafts).
+Similar problems hold for tuples's other comparison operators.
 
          
 
 
          [
-Batavia (2009-05):
+Post Summit:
 ]
          
 
+
 
          
-Move to NAD Editorial.
+Recommend Tentatively Ready.
 
          
 
 
+
 
          Proposed resolution:
          
 
          
-Restore the non-normative note. It might need to be expressed in terms of concepts.
+In 20.5.1 [tuple.general] and 20.5.2.7 [tuple.rel] change:
 
          
 
+
          template<class... TTypes, class... UTypes>
+  requires EqualityComparableHasEqualTo<TTypes, UTypes>...
+  bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>...
+  bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires EqualityComparableHasEqualTo<TTypes, UTypes>...
+  bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<UTTypes, TUTypes>... && HasLess<UTypes, TTypes>...
+  bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<UTTypes, TUTypes>... && HasLess<UTypes, TTypes>...
+  bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
+template<class... TTypes, class... UTypes>
+  requires LessThanComparableHasLess<TTypes, UTypes>... && HasLess<UTypes, TTypes>...
+  bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);
+
          
+
 
 
 
 
 
          
-
          972. The term "Assignable" undefined but still in use
          
-
          Section: 17 [library] Status: NAD Editorial
- Submitter: Niels Dekker Opened: 2009-01-07  Last modified: 2009-07-13
          
-
          View other active issues in [library].
          
-
          View all other issues in [library].
          
-
          View all issues with NAD Editorial status.
          
+
          930. Access to std::array data as built-in array type
          
+
          Section: 23.3.1 [array] Status: NAD
+ Submitter: Niels Dekker Opened: 2008-11-17  Last modified: 2009-10-20
          
+
          View all other issues in [array].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
+
 
          
-Previous versions of the Draft had a table, defining the Assignable 
-requirement.  For example 
-N2134
-Table 79, "Assignable requirements". But I guess the term "Assignable" 
-is outdated by now, because the current Committee Draft provides 
-MoveAssignable, CopyAssignable, and TriviallyCopyAssignable concepts 
-instead. And as far as I can see, it no longer has a definition of 
-Assignable. (Please correct me if I'm wrong.) Still the word 
-"Assignable" is used in eight places in the Draft, 
-N2800.
+The Working Draft (N2798) allows access to the elements of
+std::array by its data() member function:
 
          
 
+
          
+
+
          23.2.1.4 array::data [array.data]
          
+
           T *data();
+ const T *data() const;
+
          
+
          1. 
+ Returns: elems.
+
          
+
          
+
 
          
-Are all of those instances of "Assignable" to be replaced by "CopyAssignable"? 
+Unfortunately, the result of std::array::data() cannot be bound
+to a reference to a built-in array of the type of array::elems.
+And std::array provides no other way to get a reference to
+array::elems. 
+This hampers the use of std::array, for example when trying to
+pass its data to a C style API function:
 
          
 
-
          [
-Batavia (2009-05):
-]
          
+
           // Some C style API function. 
+ void set_path( char (*)[MAX_PATH] );
 
-
          
-Move to NAD Editorial.
-
          
+ std::array<char,MAX_PATH> path;
+ set_path( path.data() );  // error
+ set_path( &(path.data()) );  // error
+
          
+
+ 
          
+Another example, trying to pass the array data to an instance of another
+C++ class:
+
          
 
+
           // Represents a 3-D point in space.
+ class three_d_point {
+ public:
+   explicit three_d_point(const double (&)[3]); 
+ };
 
-
          Proposed resolution:
          
+ const std::array<double,3> coordinates = { 0, 1, 2 };
+ three_d_point point1( coordinates.data() );  // error.
+ three_d_point point2( *(coordinates.data()) );  // error.
+
          
 
 
          
-Change Exception Propagation 18.8.5 [propagation]:
-
          
-
          
-exception_ptr shall be DefaultConstructible, CopyConstructible,
-CopyAssignable and EqualityComparable.
-
          
+A user might be tempted to use std::array::elems instead, but
+doing so isn't recommended, because std::array::elems is "for
+exposition only".  Note that Boost.Array users might already use
+boost::array::elems, as its documentation doesn't explicitly
+state that boost::array::elems is for exposition only:
+http://www.boost.org/doc/libs/1_36_0/doc/html/boost/array.html
+
          
+
          
+I can think of three options to solve this issue:
+
          
+
          1. 
+Remove the words "exposition only" from the definition of
+std::array::elems, as well as the note saying that "elems is
+shown for exposition only."
+
          2. 
+Change the signature of std::array::data(), so that it would
+return a reference to the built-in array, instead of a pointer to its
+first element.
+
          3. 
+Add extra member functions, returning a reference to the built-in array.
+
          
+
          
+Lawrence Crowl wrote me that it might be better to leave
+std::array::elems "for exposition only", to allow alternate
+representations to allocate the array data dynamically.  This might be
+of interest to the embedded community, having to deal with very limited
+stack sizes.
+
          
+
          
+The second option, changing the return type of
+std::array::data(), would break backward compatible to current
+Boost and TR1 implementations, as well as to the other contiguous
+container (vector and string) in a very subtle way.
+For example, the following call to std::swap currently swap two
+locally declared pointers (data1, data2), for any container
+type T that has a data() member function. When
+std::array::data() is changed to return a reference, the
+std::swap call may swap the container elements instead.
+
          
+
+
           template <typename T>
+ void func(T& container1, T& container2)
+ {
+   // Are data1 and data2 pointers or references?
+   auto data1 = container1.data();
+   auto data2 = container2.data();
+
+   // Will this swap two local pointers, or all container elements?
+   std::swap(data1, data2);
+ }
+
          
 
 
          
-Change Class template reference_wrapper 20.7.5 [refwrap]:
+The following concept is currently satisfied by all contiguous
+containers, but it no longer is for std::array, when
+array::data()
+is changed to return a reference (tested on ConceptGCC Alpha 7):
 
          
-
          
-reference_wrapper<T> is a CopyConstructible and CopyAssignable wrapper around a reference to an object of type T.
-
          
+
+
           auto concept ContiguousContainerConcept<typename T>
+ {
+   typename value_type = typename T::value_type;
+   const value_type * T::data() const;
+ }
+
          
+
 
          
-Change Placeholders 20.7.12.1.4 [func.bind.place]:
+Still it's worth considering having std::array::data() return a
+reference, because it might be the most intuitive option, from a user's
+point of view.  Nicolai Josuttis (who wrote boost::array)
+mailed me that he very much prefers this option.
 
          
-
          
-It is implementation defined whether placeholder types are CopyAssignable. CopyAssignable placeholders' copy assignment operators shall not throw exceptions.
-
          
 
          
-Change Class template shared_ptr 20.8.10.2 [util.smartptr.shared]:
+Note that for this option, the definition of data() would also
+need to be revised for zero-sized arrays, as its return type cannot be a
+reference to a zero-sized built-in array.  Regarding zero-sized array,
+data() could throw an exception.  Or there could be a partial
+specialization of std::array where data() returns
+T* or gets removed.
 
          
-
          
-Specializations of shared_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable...
-
          
 
          
-Change Class template weak_ptr 20.8.10.3 [util.smartptr.weak]:
+Personally I prefer the third option, adding a new member function to
+std::array, overloaded for const and non-const access,
+returning a reference to the built-in array, to avoid those compatible
+issues. I'd propose naming the function std::array::c_array(),
+which sounds intuitive to me. Note that boost::array already
+has a c_array() member, returning a pointer, but Nicolai told
+me that this one is only there for historical reasons. (Otherwise a name
+like std::array::native_array() or
+std::array::builtin_array() would also be fine with me.) 
+According to my proposed resolution, a zero-sized std::array does not need
+to have c_array(), while it is still required to have
+data() functions.
 
          
+
+
          [
+Post Summit:
+]
          
+
+
 
          
-Specializations of weak_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable...
-
          
+
 
          
-Change traits typedefs 21.2.2 [char.traits.typedefs] (note: including deletion of reference to 23.1!):
+Alisdair: Don't like p4 suggesting implementation-defined behaviour.
 
          
-
          
-Requires: state_type shall meet the requirements of CopyAssignable (23.1), CopyConstructible (20.1.8), and DefaultConstructible types.
-
          
 
          
-Change Class seed_seq 26.5.7.1 [rand.util.seedseq] (note again: including deletion of reference to 23.1!):
+Walter: What about an explicit conversion operator, instead of adding
+the new member function?
 
          
-
          
-In addition to the requirements set forth below, instances of
-seed_seq shall meet the requirements of CopyConstructible (20.1.8) and of CopyAssignable (23.1).
-
          
-
 
          
-Note: The proposed resolution of this issue does not deal with the
-instance of the term "Assignable" in D.9.1 [auto.ptr], as this is dealt
-with more specifically by LWG 973, "auto_ptr characteristics", submitted
-by Maarten Hilferink.
+Alisdair: Noodling about:
 
          
+
          template<size_t N, ValueType T>
+struct array
+{
+  T elems[N];
 
+// fantasy code starts here
 
+// crazy decltype version for grins only
+//requires True<(N>0)>
+//explict operator decltype(elems) & () { return elems; }
 
+// conversion to lvalue ref
+requires True<(N>0)>
+explict operator T(&)[N] () & { return elems; }
 
+// conversion to const lvalue ref
+requires True<(N>0)>
+explict operator const T(&)[N] () const & { return elems; }
 
+// conversion to rvalue ref using ref qualifiers
+requires True<(N>0)>
+explict operator T(&&)[N] () && { return elems; }
+
+// fantasy code ends here
+
+explicit operator bool() { return true; }
+};
+
          
 
-
          
-
          973. auto_ptr characteristics
          
-
          Section: D.9.1 [auto.ptr] Status: NAD Editorial
- Submitter: Maarten Hilferink Opened: 2009-01-21  Last modified: 2009-07-13
          
-
          View all other issues in [auto.ptr].
          
-
          View all issues with NAD Editorial status.
          
-
          Discussion:
          
 
          
-I think that the Note of D.9.1 [auto.ptr], paragraph 3 needs a rewrite 
-since "Assignable" is no longer defined as a concept. 
-The relationship of auto_ptr with the new CopyAssignable, MoveAssignable,
- and MoveConstructible concepts should be clarified.
-Furthermore, since the use of auto_ptr is depreciated anyway,
- we can also omit a description of its intended use.
+This seems legal but odd. Jason Merrill says currently a CWG issue 613
+on the non-static data member that fixes the error that current G++
+gives for the non-explicit, non-conceptualized version of this. Verdict
+from human compiler: seems legal.
 
          
+
          
+Some grumbling about zero-sized arrays being allowed and supported.
+
          
+
          
+Walter: Would this address the issue? Are we inclined to go this route?
+
          
+
          
+Alan: What would usage look like?
+
          
+
          // 3-d point in space
+struct three_d_point
+{
+  explicit three_d_point(const double (&)[3]);
+};
 
-
          [
-Batavia (2009-05):
-]
          
+void sink(double*);
 
-
          
-We agree with the intent of the proposed resolution.
-Move to NAD Editorial.
-
          
+const std::array<double, 3> coordinates = { 0, 1, 2 };
+three_d_point point1( coordinates.data() ); //error
+three_d_point point2( *(coordinates.data()) ); // error
+three_d_point point3( coordinates ); // yay!
 
+sink(cooridinates); // error, no conversion
+
          
 
-
          Proposed resolution:
          
 
          
-Change D.9.1 [auto.ptr], paragraph 3:
+Recommended Open with new wording. Take the required clause and add the
+explicit conversion operators, not have a typedef. At issue still is use
+decltype or use T[N]. In favour of using T[N], even though use of
+decltype is specially clever.
 
          
 
-
          
-The auto_ptr provides a semantics of strict ownership. An
-auto_ptr owns the ob ject it holds a pointer to. Copying an
-auto_ptr copies the pointer and transfers ownership to the
-destination. If more than one auto_ptr owns the same ob ject at
-the same time the behavior of the program is undefined. [Note:
-The uses of auto_ptr include providing temporary
-exception-safety for dynamically allocated memory, passing ownership of
-dynamically allocated memory to a function, and returning dynamically
-allocated memory from a function.
-auto_ptr does not meet the
-CopyConstructible and Assignable requirements for
-standard library container elements and thus instantiating a standard
-library container with an auto_ptr results in undefined
-behavior.
-
-Instances of auto_ptr shall
-meet the MoveConstructible and MoveAssignable
-requirements, but do not meet the CopyConstructible and
-CopyAssignable requirements.
--- end note]
 
          
 
+
          [
+Post Summit, further discussion in the thread starting with c++std-lib-23215.
+]
          
 
 
+
          [
+2009-07 post-Frankfurt (Saturday afternoon group):
+]
          
 
 
-
          
-
          979. Bad example
          
-
          Section: 24.5.2 [move.iterators] Status: NAD Editorial
- Submitter: Howard Hinnant Opened: 2009-02-03  Last modified: 2009-07-13
          
-
          View all issues with NAD Editorial status.
          
-
          Discussion:
          
+
          
 
          
-24.5.2 [move.iterators] has an incorrect example:
+The idea to resolve the issue by adding explicit conversion operators
+was abandoned, because it would be inconvenient to use, especially when
+passing the array to a template function, as mentioned by Daniel. So we
+reconsidered the original proposed resolution, which appeared
+acceptable, except for its proposed changes to 23.3.1.6 [array.zero], which
+allowed c_array_type and c_array() to be absent for a zero-sized array.
+Alisdair argued that such wording would disallow certain generic use
+cases. New wording for 23.3.1.6 [array.zero] was agreed upon (Howard: and
+is reflected in the proposed resolution).
 
          
+
          
+Move to Review
+
          
+
          
+
+
          [
+2009-07-31 Alisdair adds:
+]
          
+
 
 
          
 
          
--2- [Example:
+I will be unhappy voting the proposed resolution for 930 past review
+until we have implementation experience with reference qualifiers. 
+Specifically, I want to understand the impact of the missing overload
+for const && (if any.)
 
          
 
-
          set<string> s; 
-// populate the set s 
-vector<string> v1(s.begin(), s.end());          // copies strings into v1 
-vector<string> v2(make_move_iterator(s.begin()), 
-                  make_move_iterator(s.end())); // moves strings into v2
-
          
-
 
          
--- end example]
+If we think the issue is important enough it might be worthwhile
+stripping the ref qualifiers for easy progress next meeting, and opening
+yet another issue to put them back with experience.
 
          
-
          
 
 
          
-One can not move from a set because the iterators return const
-references.
+Recommend deferring any decision on splitting the issue until we get LWG
+feedback next meeting - I may be the lone dissenting voice if others are
+prepared to proceed without it.
 
          
+
          
 
 
          [
-Batavia (2009-05):
+2009-10 Santa Cruz:
 ]
          
 
+
 
          
-We agree with the proposed resolution. Move to NAD Editorial.
+Mark as NAD. There was not enough consensus that this was sufficiently
+useful. There are known other ways to do this, such as small inline
+conversion functions.
 
          
 
 
 
 
          Proposed resolution:
          
 
          
-Change 24.5.2 [move.iterators]/2:
+Add to the template definition of array, 23.3.1 [array]/3:
 
          
 
 
          
-
          
--2- [Example:
-
          
+
          
+typedef T c_array_type[N];
+c_array_type & c_array() &;
+c_array_type && c_array() &&;
+const c_array_type & c_array() const &;
+
+
          
+
          
 
-
          setlist<string> s; 
-// populate the setlist s 
-vector<string> v1(s.begin(), s.end());          // copies strings into v1 
-vector<string> v2(make_move_iterator(s.begin()), 
-                  make_move_iterator(s.end())); // moves strings into v2
-
          
+
          
+Add the following subsection to 23.3.1 [array], after 23.3.1.4 [array.data]:
+
          
 
+
          
+
          23.2.1.5 array::c_array [array.c_array]
          
+    
          
+c_array_type & c_array() &;
+c_array_type && c_array() &&;
+const c_array_type & c_array() const &;
+
          
+
          
 
          
--- end example]
+Returns: elems.
 
          
 
          
 
+
          
 
 
 
-
-
          
-
          980. mutex lock() missing error conditions
          
-
          Section: 30.4.1 [thread.mutex.requirements] Status: NAD
- Submitter: Ion Gaztańaga Opened: 2009-02-07  Last modified: 2009-03-22
          
-
          View other active issues in [thread.mutex.requirements].
          
-
          View all other issues in [thread.mutex.requirements].
          
-
          View all issues with NAD status.
          
-
          Discussion:
          
 
          
-POSIX 2008 adds two return values for pthread_mutex_xxxlock():
-EOWNERDEAD (owner_dead) and ENOTRECOVERABLE
-(state_not_recoverable). In the first case the mutex is locked,
-in the second case the mutex is not locked.
+Change Zero sized arrays 23.3.1.6 [array.zero]:
 
          
 
+
          
+
+
          -2- ...
          
+
+
          
+The type c_array_type is unspecified for a zero-sized array.
+
          
+
 
          
-Throwing an exception in the first case can be incompatible with the use
-of Locks, since the Lock::owns_lock() will be false when the lock is
-being destroyed.
+-3- The effect of calling c_array(), front(), or
+back() for a zero-sized array is implementation defined.
 
          
+
          
+
+
 
+
+
+
+
          
+
          933. Unique_ptr defect
          
+
          Section: 20.8.14.2.5 [unique.ptr.single.modifiers] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2008-11-27  Last modified: 2009-10-23
          
+
          View all other issues in [unique.ptr.single.modifiers].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
 
          
-Consider:
+If we are supporting stateful deleters, we need an overload for
+reset that
+takes a deleter as well.
 
          
 
-
          //Suppose mutex.lock() throws "owner_dead"
-unique_lock ul(&mutex);
-//mutex left locked if "owner_dead" is thrown
+
          void reset( pointer p, deleter_type d);
 
          
 
 
          
-Throwing an exception with owner_dead might be also undesirable if
-robust-mutex support is added to C++ and the user has the equivalent of
-pthread_mutex_consistent() to notify the user has fixed the corrupted
-data and the mutex state should be marked consistent.
+We probably need two overloads to support move-only deleters, and
+this
+sounds uncomfortably like the two constructors I have been ignoring
+for
+now...
 
          
 
-
            
-
          1. 
-For state_not_recoverable add it to the list of Error conditions:
-
            2. 
-
          2. 
-For owner_dead, no proposed resolution.
-
            3. 
-
          
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Howard comments that we have the functionality via move-assigment.
+
          
+
          
+Move to Open.
+
          
+
          
 
 
          [
-Summit:
+2009-10 Santa Cruz:
 ]
          
 
 
 
          
-Not a defect. Handling these error conditions is an implementation
-detail and must be handled below the C++ interface.
+Mark as NAD Future.
 
          
 
 
 
 
          Proposed resolution:
          
-
-
          
-Add to 30.4.1 [thread.mutex.requirements], p12:
-
          
-
-
          
 
          
--12- Error conditions:
 
          
 
-
            
-
          • 
-operation_not_permitted -- if the thread does not have the necessary permission to change 
-the state of the mutex.
-
            • 
-
          • 
-resource_deadlock_would_occur -- if the current thread already owns the mutex and is able 
-to detect it.
-
            • 
-
          • 
-device_or_resource_busy --  if the mutex is already locked and blocking is not possible.
-
            • 
-
          • 
-state_not_recoverable -- if the state protected by the mutex is not recoverable.
-
            • 
-
          
-
          
-
 
 
 
 
 
          
-
          988. Reflexivity meaningless?
          
-
          Section: 20.2.6 [concept.comparison] Status: NAD
- Submitter: Alisdair Meredith Opened: 2009-02-24  Last modified: 2009-07-16
          
-
          View all other issues in [concept.comparison].
          
-
          View all issues with NAD status.
          
+
          935. clock error handling needs to be specified
          
+
          Section: 20.9.5 [time.clock] Status: NAD Future
+ Submitter: Beman Dawes Opened: 2008-11-24  Last modified: 2009-10-23
          
+
          View all issues with NAD Future status.
          
 
          Discussion:
          
 
          
-20.2.6 [concept.comparison] p2:
+Each of the three clocks specified in Clocks 20.9.5 [time.clock]
+provides the member function:
 
          
+
+
          static time_point now();
+
          
+
 
          
-Due to the subtle meaning of == inside axioms, the Reflexivity axiom does
-not do anything as written. It merely states that a value is substitutable
-with itself, rather than asserting a property of the == operator.
+The semantics specified by Clock requirements 20.9.1 [time.clock.req]
+make no mention of error handling. Thus the function may throw bad_alloc
+or an implementation-defined exception (17.6.4.11 [res.on.exception.handling]
+paragraph 4).
 
          
 
-
-Original proposed resolution:
-
+
          
+Some implementations of these functions on POSIX, Windows, and
+presumably on other operating systems, may fail in ways only detectable
+at runtime. Some failures on Windows are due to supporting chipset
+errata and can even occur after successful calls to a clock's now()
+function.
+
          
 
 
          
-Change the definition of Reflexivity in 20.2.6 [concept.comparison]:
+These functions are used in cases where exceptions are not appropriate
+or where the specifics of the exception or cause of error need to be
+available to the user. See
+N2828,
+Library Support for hybrid error
+handling (Rev 1), for more specific discussion of use cases. Thus some change in
+the interface of now is required.
 
          
 
-
          axiom Reflexivity(T a) { (a == a) == true; }
-
          
+
          
+The proposed resolution has been implemented in the Boost version of the
+chrono library. No problems were encountered.
+
          
 
 
          [
-Post Summit:
+Batavia (2009-05):
 ]
          
 
-
 
          
 
          
-Alisdair: I was wrong.
+We recommend this issue be deferred until the next Committee Draft
+has been issued and the prerequisite paper has been accepted.
 
          
 
          
-Recommend NAD.
+Move to Open.
 
          
 
          
 
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD future. Too late to make this change without having already
+accepted the hybrid error handling proposal.
+
          
+
 
 
 
          Proposed resolution:
          
 
          
-NAD.
+Accept the proposed wording of
+N2828,
+Library Support for hybrid error handling (Rev 1).
 
          
 
+
          
+Change Clock requirements 20.9.1 [time.clock.req] as indicated:
+
          
 
+
          
+
          
+-2- In Table 55 C1 and C2 denote clock types. t1 and
+t2 are values returned by C1::now() where the call 
+returning t1 happens before (1.10) the call returning t2 and
+both of these calls happen before C1::time_point::max().
+ec denotes an object of type error_code 
+(19.5.2.1 [syserr.errcode.overview]).
+
          
 
+
+
+
+
+
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
          Table 55 -- Clock requirements
          ExpressionReturn typeOperational semantics
          .........
          C1::now()C1::time_pointReturns a time_point object representing the current point in time.
+
          C1::now(ec)C1::time_pointReturns a time_point object representing the current point in time.
+
          
+
          
 
-
          
-
          989. late_check and library
          
-
          Section: 17 [library] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-02-24  Last modified: 2009-07-16
          
-
          View other active issues in [library].
          
-
          View all other issues in [library].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
 
          
-The example in 6.9p2 shows how late_check blocks inhibit concept_map lookup
-inside a constrained context, and so inhibit concept map adaption by users
-to meet template requirements.
+Change Class system_clock 20.9.5.1 [time.clock.system] as indicated:
 
          
+
+
          static time_point now(error_code& ec=throws());
+
          
+
 
          
-Do we need some text in clause 17 prohibitting use of late_check in library
-template definitions unless otherwise documented?
+Change Class monotonic_clock 20.9.5.2 [time.clock.monotonic] as indicated:
 
          
 
-
          [
-Doug adds:
-]
          
+
          static time_point now(error_code& ec=throws());
+
          
 
+
          
+Change Class high_resolution_clock 20.9.5.3 [time.clock.hires] as indicated:
+
          
 
-
          
-We need something like this, but it should be a more general statement
-about implementations respecting the concept maps provided by the
-user. Use of late_check is one way in which implementations can
-subvert the concept maps provided by the user, but there are other
-ways as well ("pattern-based" overloading, tricks with "auto" concept
-maps and defaulted associated type arguments).
-
          
+
          static time_point now(error_code& ec=throws());
+
          
 
-
          [
-Batavia (2009-05):
-]
          
 
-
          
-Move to Open, pending proposed wording from Alisdair and/or Doug for further review.
-
          
 
 
-
          Proposed resolution:
          
 
 
+
          
+
          936. Mutex type overspecified
          
+
          Section: 30.4.1 [thread.mutex.requirements] Status: NAD Future
+ Submitter: Pete Becker Opened: 2008-12-05  Last modified: 2009-10-23
          
+
          View other active issues in [thread.mutex.requirements].
          
+
          View all other issues in [thread.mutex.requirements].
          
+
          View all issues with NAD Future status.
          
+
          Duplicate of: 961
          
+
          Discussion:
          
 
 
 
-
          
-
          992. Response to UK 169
          
-
          Section: 17.6.1.1 [contents] Status: NAD
- Submitter: P.J. Plauger Opened: 2009-03-03  Last modified: 2009-07-22
          
-
          View all other issues in [contents].
          
-
          View all issues with NAD status.
          
-
          Discussion:
          
-
          Addresses UK 169
          
 
          
-This phrasing contradicts later freedom to implement the C standard
-library portions in the global namespace as well as std. (17.6.2.3p4)
+30.4.1 [thread.mutex.requirements] describes the requirements for a type to be
+a "Mutex type". A Mutex type can be used as the template argument for
+the Lock type that's passed to condition_variable_any::wait (although
+Lock seems like the wrong name here, since Lock is given a different
+formal meaning in 30.4.3 [thread.lock]) and, although the WD doesn't quite say
+so, as the template argument for lock_guard and unique_lock.
+
          
+
+
          
+The requirements for a Mutex type include:
+
          
+
+
            
+
          • 
+m.lock() shall be well-formed and have [described] semantics, including a return type of void.
+
            • 
+
          • 
+m.try_lock() shall be well-formed and have [described] semantics, including a return type of bool.
+
            • 
+
          • 
+m.unlock() shall be well-formed and have [described] semantics, including a return type of void.
+
            • 
+
          
+
+
          
+Also, a Mutex type "shall not be copyable nor movable".
+
          
+
+
          
+The latter requirement seems completely irrelevant, and the three
+requirements on return types are tighter than they need to be. For
+example, there's no reason that lock_guard can't be instantiated with a
+type that's copyable. The rule is, in fact, that lock_guard, etc. won't
+try to copy objects of that type. That's a constraint on locks, not on
+mutexes. Similarly, the requirements for void return types are
+unnecessary; the rule is, in fact, that lock_guard, etc. won't use any
+returned value. And with the return type of bool, the requirement should
+be that the return type is convertible to bool.
 
          
 
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+
 
          
-The proposed wording seems to go too far.
-Move back to Open.
+
          
+Move to open. Related to conceptualization and should probably be tackled as part of that.
+
          
+
            
+
          • 
+The intention is not only to place a constraint on what types such as
+lock_guard may do with mutex types, but on what any code, including user
+code, may do with mutex types. Thus the constraints as they are apply to
+the mutex types themselves, not the current users of mutex types in the
+standard.
+
            • 
+
          • 
+This is a low priority issue; the wording as it is may be overly
+restrictive but this may not be a real issue.
+
            • 
+
          
 
          
 
 
          [
-2009-07 Frankfurt:
+Post Summit Anthony adds:
 ]
          
 
 
 
          
 
          
-Howard to add NB reference to the description of this issue.
-
          
-
          
-Move to NAD. This comment is informative and not normative by the use of
-the word "are" instead of the word "shall."
-
          
-
          
-A note linking to Annex D would help clarify the intention, here.
+Section 30.4.1 [thread.mutex.requirements] conflates the
+requirements on a generic Mutex type (including user-supplied mutexes)
+with the requirements placed on the standard-supplied mutex types in an
+attempt to group everything together and save space.
 
          
 
          
-Robert to Open a separate issue proposing that the standard C headers be
-undeprecated, for the purpose of clarifying the standard.
+When applying concepts to chapter 30, I suggest that the concepts
+Lockable and TimedLockable embody the requirements for
+*use* of a mutex type as required by
+unique_lock/lock_guard/condition_variable_any. These should be
+relaxed as Pete describes in the issue. The existing words in 30.4.1 [thread.mutex.requirements] are requirements on all of
+std::mutex, std::timed_mutex,
+std::recursive_mutex and std::recursive_timed_mutex,
+and should be rephrased as such.
 
          
 
          
 
-
          [
-2009-07-22 Bill modified the proposed wording with a clarifying footnote.
-]
          
-
-
 
 
 
          Proposed resolution:
          
 
          
-Add a footnote to 17.6.1.1 [contents], p2:
 
          
 
+
+
+
+
+
          
+
          937. Atomics for standard typedef types
          
+
          Section: 29 [atomics] Status: NAD Editorial
+ Submitter: Clark Nelson Opened: 2008-12-05  Last modified: 2009-05-23
          
+
          View all other issues in [atomics].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses US 89
          
+
 
          
 
          
--2- All library entities except macros, operator new and operator
-delete are defined within the namespace std or namespaces
-nested within namespace std*.
+The types in the table "Atomics for standard typedef types" should be
+typedefs, not classes. These semantics are necessary for compatibility
+with C.
 
          
 
-
          
-*The C standard library headers D.5 [depr.c.headers] also define
-names within the global namespace, while the C++ headers for
-C library facilities 17.6.1.2 [headers] may also define names within
-the global namespace.
-
          
+
          
+Change the classes to typedefs.
+
          
 
          
 
+
          
+N2427
+specified different requirements for atomic analogs of fundamental
+integer types (such as atomic_int) and for atomic analogs of <cstdint>
+typedefs (such as atomic_size_t). Specifically, atomic_int et al. were
+specified to be distinct classes, whereas atomic_size_t et al. were
+specified to be typedefs. Unfortunately, in applying
+N2427
+to the WD, that distinction was erased, and the atomic analog of every <cstdint>
+typedef is required to be a distinct class.
+
          
 
+
          
+It shouldn't be required that the atomic analog of every <cstdint>
+typedef be a typedef for some fundamental integer type. After all,
+<cstdint> is supposed to provide standard names for extended integer
+types. So there was a problem in
+N2427,
+which certainly could have been
+interpreted to require that. But the status quo in the WD is even worse,
+because it's unambiguously wrong.
+
          
 
-
-
-
-
          
-
          995. Operational Semantics Unclear
          
-
          Section: 17.5.1.3 [structure.requirements] Status: NAD
- Submitter: David Abrahams Opened: 2009-03-06  Last modified: 2009-07-13
          
-
          View all issues with NAD status.
          
-
          Discussion:
          
 
          
-As a practical matter there's disagreement on the meaning of operational
-semantics.  If the text in 17.5.1.3 [structure.requirements]p4 isn't
-clear, it should be clarified.  However, it's not clear whether the
-disagreement is merely due to people not being aware of the text.
+What is needed are words to require the existence of a bunch of type
+names, without specifying whether they are class names or typedef names.
 
          
 
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+
 
          
-Agree with the recommended NAD resolution.
+
          
+Change status to NAD, editorial. See US 89 comment notes above.
+
          
+
          
+Direct the editor to turn the types into typedefs as proposed in the
+comment. Paper approved by committee used typedefs, this appears to have
+been introduced as an editorial change. Rationale: for compatibility
+with C.
+
          
 
          
 
 
 
          Proposed resolution:
          
 
          
-Recommend NAD.  The text in 17.5.1.3 [structure.requirements] is
-perfectly clear.
 
          
 
 
@@ -24084,386 +28106,273 @@ perfectly clear.
 
 
 
          
-
          1000. adjacent_find is over-constrained
          
-
          Section: 25.3.8 [alg.adjacent.find] Status: NAD Concepts
- Submitter: Chris Jefferson Opened: 2009-03-09  Last modified: 2009-07-15
          
-
          View all other issues in [alg.adjacent.find].
          
-
          View all issues with NAD Concepts status.
          
+
          941. Ref-qualifiers for assignment operators
          
+
          Section: 17 [library] Status: NAD
+ Submitter: Niels Dekker Opened: 2008-12-18  Last modified: 2009-07-17
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
 
          
-Addresses UK 296
+The assignment and equality operators = and == are easily confused, just
+because of their visual similarity, and in this case a simple typo can cause
+a serious bug. When the left side of an operator= is an rvalue, it's
+highly unlikely that the assignment was intended by the programmer:
 
          
-
+
          if ( func() = value )  // Typical typo: == intended!
+
          
 
          
-adjacent_find in C++03 allows an arbitrary predicate, but in C++0x
-EqualityComparable/EquivalenceRelation is required. This forbids a
-number of use cases, including:
+Built-in types don't support assignment to an rvalue, but unfortunately,
+a lot of types provided by the Standard Library do.
+
          
+
          
+Fortunately the language now offers a syntax to prevent a certain member
+function from having an rvalue as *this: by adding a ref-qualifier (&)
+to the member function declaration.  Assignment operators are explicitly
+mentioned as a use case of ref-qualifiers, in "Extending Move Semantics
+To *this (Revision 1)",
+N1821 by Daveed
+Vandevoorde and Bronek Kozicki
+
          
+
          
+Hereby I would like to propose adding ref-qualifiers to all appropriate
+assignment operators in the library.
 
          
+
+
          [
+Batavia (2009-05):
+]
          
+
 
          
-
-
-
-
-
-
-
-
-
-
          
-adjacent_find(begin, end, less<double>)
-
-Find the first
-place where a range is not ordered in decreasing order - in use to check
-for sorted ranges.
-
          
-adjacent_find(begin, end, DistanceBiggerThan(6) ) )
-
-Find the first
-place in a range where values differ by more than a given value - in use
-to check an algorithm which produces points in space does not generate
-points too far apart.
-
          
+Move to Open.
+We recommend this be deferred until after the next Committee Draft.
 
          
 
+
          [
+Frankfurt 2009-07:
+]
          
+
+
+
          
 
          
-A number of books use predicate which are not equivalence relations in
-examples, including "Thinking in C++" and "C++ Primer".
+The LWG declined to move forward with
+N2819.
 
          
-
 
          
-Adding the requirement that the predicate is an EquivalenceRelation
-does not appear to open up any possibility for a more optimised algorithm.
+Moved to NAD.
 
          
-
+
          
 
 
 
          Proposed resolution:
          
 
          
-Change the definition of adjacent_find in the synopsis of 25 [algorithms]
-and 25.3.8 [alg.adjacent.find] to:
+A proposed resolution is provided by the paper on this subject,
+N2819,
+Ref-qualifiers for assignment operators of the Standard Library
 
          
 
-
          template<ForwardIterator Iter> 
-  requires EqualityComparableHasEqualTo<Iter::value_type, Iter::value_type>
-  Iter adjacent_find(Iter first, Iter last);
-
-template<ForwardIterator Iter, EquivalenceRelationPredicate<auto, Iter::value_type, Iter::value_type> Pred> 
-  requires CopyConstructible<Pred> 
-  Iter adjacent_find(Iter first, Iter last, Pred pred);
-
          
-
 
 
 
 
 
          
-
          1001. Pointers, concepts and headers
          
-
          Section: 17 [library] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-10  Last modified: 2009-07-18
          
-
          View other active issues in [library].
          
-
          View all other issues in [library].
          
-
          View all issues with NAD Concepts status.
          
+
          942. Atomics synopsis typo
          
+
          Section: 29 [atomics] Status: Dup
+ Submitter: Holger Grund Opened: 2008-12-19  Last modified: 2009-03-22
          
+
          View all other issues in [atomics].
          
+
          View all issues with Dup status.
          
+
          Duplicate of: 880
          
 
          Discussion:
          
 
-
          Addresses UK 78
          
 
-
          
-Related to 1063.
-
          
 
 
          
-This is effectively an extension of LWG issue 343.
+I'm looking at 29 [atomics] and can't really make sense of a couple of things.
 
          
 
          
-We know there is an increasing trend (encouraged by conformance testers and
-some users) that each library header should supply no more than required to
-satisfy the synopsis in the standard.  This is typically achieved by
-breaking larger headers into smaller subsets, and judicious use of forward
-declarations.
+Firstly, there appears to be a typo in the <cstdatomic> synopsis:
 
          
+
+
          
 
          
-If we apply this policy to C++0x (per
-N2800)
-it will be very surprising for
-people using library algorithms over ranges defined by pointers that they
-must #include <iterator_concepts> for their code to compile again.  That is
-because pointers do not satisfy any of the iterator concepts without the
-concept_map supplied in this header.
+The atomic_exchange overload taking an atomic_address
+is missing the second parameter:
 
          
+
+
          void* atomic_exchange(volatile atomic_address*);
+
          
+
 
          
-Therefore, I suggest we should require all library headers that make use of
-iterator concepts are specifically required to #include <iterator_concepts>.
+should be
 
          
+
+
          void* atomic_exchange(volatile atomic_address*, void*);
+
          
+
 
          
-At a minimum, the list of headers would be: (assuming all are constrained by
-concepts)
+Note, that this is not covered by 880 "Missing atomic exchange parameter",
+which only talks about the atomic_bool.
 
          
-
          algorithm
-array
-deque
-forward_list
-initializer_list
-iterator
-locale
-list
-map
-memory          // if 1029 is adopted
-memory_concepts
-numeric
-random
-regex
-set
-string
-tuple
-unordered_map
-unordered_set
-utility
-vector
-
          
+
          
 
-
          [
-Ganesh adds:
-]
          
 
 
-
          
+
          Proposed resolution:
          
 
          
-The same problems exists for <memory_concepts> and
-<container_concepts>.
-
          
-
          
-In order to compile <vector> you just need the
-definitions of the concepts in <memory_concepts>, the
-concept maps defined there are not necessary. Yet, from the user point
-of view, if the concept map template for AllocatableElement are
-not in scope, <vector> is pretty useless. Same for
-<tuple> and ConstructibleWithAllocator.
-
          
-
          
-Similarly, <queue> is not very useful if the concept map
-template for QueueLikeContainer is not in scope, although the
-definition of concept alone is theoretically sufficient.
-
          
-
          
-There's a pattern here: if a concept has concept maps "attached", they
-should never be separated.
+Change the synopsis in 29 [atomics]/2:
 
          
-
          
 
-
          [
-Beman provided the proposed resolution for the May 2009 mailing. He 
-comments:
-]
          
+
          void* atomic_exchange(volatile atomic_address*, void*);
+
          
 
 
-
          
 
-
          Initially I tried to specify exactly what header should include what other 
-headers. This was verbose, error prone, hard to maintain, and appeared to add 
-little value compared to just stating the general rule.
          
 
-
          
 
-
          [
-Batavia (2009-05):
-]
          
 
-
          
-
          
-Pete believes the proposed wording overconstrains implementers.
-Instead of specifying the mechanism,
-he prefers a solution that spells out what needs to be declared,
-rather than how those declarations are to be provided,
-e.g.,
-
          
-
          
-A C++ header shall provide the names
-that are required to be defined in that header.
-
          
+
          
+
          944. atomic<bool> derive from atomic_bool?
          
+
          Section: 29.5.3 [atomics.types.generic] Status: NAD Editorial
+ Submitter: Holger Grund Opened: 2008-12-19  Last modified: 2009-10-26
          
+
          View all other issues in [atomics.types.generic].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
 
          
-Bill suggests approaching the wording from a programmer's perspective.
-We may want to consider promising that certain widely-used headers
-(e.g., the concept headers) are included when needed by other headers.
-He feels, however, there is nothing broken now,
-although we may want to consider "something nicer."
+I think it's fairly obvious that atomic<bool> is supposed to be derived
+from atomic_bool (and otherwise follow the atomic<integral> interface),
+though I think the current wording doesn't support this. I raised this
+point along with atomic<floating-point> privately with Herb and I seem
+to recall it came up in the resulting discussion on this list. However,
+I don't see anything on the current libs issue list mentioning this
+problem.
 
          
+
 
          
-Move to Open status.
+29.5.3 [atomics.types.generic]/3 reads
 
          
 
+
          
+There are full specializations over the integral types on the atomic
+class template. For each integral type integral in the second column of
+table 121 or table 122, the specialization atomic<integral> shall be
+publicly derived from the corresponding atomic integral type in the
+first column of the table. These specializations shall have trivial
+default constructors and trivial destructors.
 
          
 
+
          
+Table 121 does not include (atomic_bool, bool),
+so that this should probably be mentioned explicitly in the quoted paragraph.
+
          
+
 
          [
-2009-06-16 Beman updated the proposed resolution:
+Summit:
 ]
          
 
 
 
          
-  
            
-    
          • The mechanism is no longer specified, as requested in Batavia.
            • 
-    
          • The footnote has been removed since it specified mechanism and also did 
-    not reflect existing practice.
            • 
-    
          • A sentence was added that makes it clear that the existing practice is 
-    permitted.
            • 
-  
          
+Move to open. Lawrence will draft a proposed resolution. Also, ask
+Howard to fix the title.
 
          
 
 
          [
-2009-07-15 Beman updated the proposed resolution:
-]
          
-
-
-
          [
-2009-07-17 Beman updated the proposed resolution based on feedback from the LWG in Frankfurt:
+Post Summit Anthony provided proposed wording.
 ]
          
 
 
-
          
-
            
-
          • Strike two pieces of text considered unnecessary.
            • 
-
          • Change "definitions" to "declarations and definitions" in two places.
            • 
-
          • Wording tightened slightly.
            • 
-
          
-
          
-
 
          [
-2009-07 Frankfurt:
+2009-10 Santa Cruz:
 ]
          
 
 
 
          
-
          
-Revised Proposed Resolution:
-
          
-
          
-A C++ header may include other C++ headers. A C++ header shall provide
-the declarations and definitions that appear in its synopsis (3.2
-[basic.def.odr]). A C++ header shown in its synopsis as including other
-C++ headers shall provide the declarations and definitions that appear
-in the synopses of those other headers.
-
          
-
          
-Alisdair: Does this address the BSI comment?
-
          
-
          
-Beman: There were several overlapping comments. I tried to handle them
-all with one resolution.
-
          
-
          
-Alisdair: I'd prefer to see this closed as NAD and have this resolution
-be the subject of some other, new issue.
-
          
-
          
-Move to NAD Concepts. Howard to open a new issue (1178) in Ready state with the
-Proposed Resolution above. Beman will write up a discussion for the new
-issue.
-
          
+NAD Editorial.  Solved by
+N2992.
 
          
 
 
 
 
          Proposed resolution:
          
-
          Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:
          
-
-
          
-
 
          
-A C++ header may include other C++
-headers.[footnote] A C++ header shall provide
-the declarations and definitions that appear in its synopsis
-(3.2 [basic.def.odr]). A C++ header shown in its synopsis as including 
-other C++ headers shall provide the same declarations and definitions as
-if those other headers were included.
+Replace paragraph 3 in 29.5.3 [atomics.types.generic] with
 
          
 
-  
          [footnote] C++ headers must include a C++ header that contains 
-  any needed definition (3.2).
          
+
          
+-3- There are full specializations over the integral types on the atomic
+class template. For each integral type integral in the second column of
+table 121 or table 122, the specialization atomic<integral> shall be
+publicly derived from the corresponding atomic integral type in the first
+column of the table.
+In addition, the specialization atomic<bool>
+shall be publicly derived from atomic_bool.
+These specializations shall have trivial default
+constructors and trivial destructors.
 
          
 
 
 
 
 
-
 
          
-
          1002. Response to UK 170
          
-
          Section: 17.6.1.2 [headers] Status: NAD
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all other issues in [headers].
          
-
          View all issues with NAD status.
          
+
          945. system_clock::rep not specified
          
+
          Section: 20.9.5.1 [time.clock.system] Status: NAD Editorial
+ Submitter: Pete Becker Opened: 2008-12-19  Last modified: 2009-07-13
          
+
          View all other issues in [time.clock.system].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
-
          Addresses UK 170
          
-
 
          
-One of goals of C++0x is to make language easier to teach and for
-'incidental' programmers. The fine-grained headers of the C++ library
-are valuable in large scale systems for managing dependencies and
-optimising build times, but overcomplicated for simple development and
-tutorials. Add additional headers to support the whole library through a
-single include statement.
+In 20.9.5.1 [time.clock.system], the declaration of system_clock::rep says "see
+below", but there is nothing below that describes it.
 
          
 
 
          [
-Batavia (2009-05):
-]
          
-
-
          
-We do not all agree that this is an issue,
-but we agree that if it needs solving this is the right way to do it.
-Move to Tentatively Ready.
-
          
-
-
          [
-2009-07-06 Beman notes:
+Howard adds:
 ]
          
 
 
 
          
 
          
-This issue
-adds a header <std>.
-
          
-
          
-There is a paper to be looked at,
-N2905
-Aggregation headers, that adds
-a header <std-all> that is the same thing except it excludes
-deprecated headers.
-N2905
-also proposes a second aggregation header.
+This note refers to:
 
          
+
+
          
+-2- system_clock::duration::min() < system_clock::duration::zero() shall be true.
+
          
+
 
          
-Seems like this issue should be held in abeyance until the LWG has had
-a chance to look at N2905.
+I.e. this is standardeze for "system_clock::rep is signed".
+Perhaps an editorial note along the lines of:
 
          
+
+
          
+-2- system_clock::duration::min() < system_clock::duration::zero()
+shall be true. [Note: system_clock::rep shall be signed. -- end note].
 
          
 
-
          [
-2009-07-06 Howard:  I've pulled this issue back to Review.
-]
          
+
          
+?
+
          
 
+
          
 
 
          [
-2009-07 Frankfurt
+Batavia (2009-05):
 ]
          
 
-
 
          
-No consensus for change.
+We agree with the direction of the proposed resolution.
+Move to NAD Editorial.
 
          
 
 
 
 
          Proposed resolution:
          
 
          
-Insert a new paragraph in 17.6.1.2 [headers] between p4 and p5
+Add a note to 20.9.5.1 [time.clock.system], p2:
 
          
 
          
-An additional header <std> shall have the effect of
-supplying the entire standard library.  [Note: for example, it
-might be implemented as a file with an #include statement for each of the
-headers listed in tables 13 and 14. -- end note]
+-2- system_clock::duration::min() < system_clock::duration::zero()
+shall be true. [Note: system_clock::rep shall be signed. -- end note].
 
          
 
 
@@ -24471,86 +28380,63 @@ headers listed in tables 13 and 14. -- end note]
 
 
 
          
-
          1003. Response to JP 23
          
-
          Section: 17.6.1.3 [compliance] Status: NAD
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
          
-
          View all other issues in [compliance].
          
+
          946. duration_cast improperly specified
          
+
          Section: 20.9.3.7 [time.duration.cast] Status: NAD
+ Submitter: Pete Becker Opened: 2008-12-20  Last modified: 2009-07-13
          
+
          View all other issues in [time.duration.cast].
          
 
          View all issues with NAD status.
          
 
          Discussion:
          
+20.9.3.7 [time.duration.cast]/3:
 
-
          Addresses JP 23
          
+
          
+.... All intermediate computations shall be
+carried out in the widest possible representation... .
+
          
 
 
          
-There is a freestanding implementation including
-<type_traits>, <array>,
-<ratio>, lately added to Table 13, C++ library headers.
-Programmers think them useful and hope that these headers are also added
-to Table 15, C++ headers for freestanding implementations, that shows
-the set of headers which a freestanding implementation shall include at
-least.
+So ignoring
+floating-point types for the moment, all this arithmetic has to be done
+using the implementation's largest integral type, even if both arguments
+use int for their representation. This seems excessive. And it's not at
+all clear what this means if we don't ignore floating-point types.
 
          
 
-
          Original proposed resolution
          
-
 
          
-Add <type_traits>, <array>,
-<ratio> to Table 15.
+This issue is related to 952.
 
          
 
 
          [
-Summit:
+Howard adds:
 ]
          
 
 
 
          
 
          
- The <array> header has far too many dependencies to require for a
-free-standing implementation.
-
          
-
          
-The <ratio> header would be useful, has no dependencies, but is not
-strictly necessary.
+The intent of this remark is that intermediate computations are carried out
+using:
 
          
+
+
          common_type<typename ToDuration::rep, Rep, intmax_t>::type
+
          
+
 
          
-The <type_traits> header is fundamentally a core language facility with a
-library interface, so should be supported.
+The Remark was intended to be clarifying prose supporting the rather algorithmic description
+of the previous paragraph.  I'm open to suggestions.  Perhaps the entire paragraph
+3 (Remarks) would be better dropped?
 
          
-
-
          
-(it is anticipated the resolution will come via an update to paper
-N2814)
-(see also LWG 833)
-
          
-
          
+
          
 
 
          [
 Batavia (2009-05):
 ]
          
 
 
          
-Leave in Review status pending a paper on freestanding implementations
-by Martin Tasker.
-
          
-
-
          [
-2009-07 Frankfurt:
-]
          
-
-
-
          
-
          
-Move this to NAD.
-
          
 
          
-We considered all of the listed headers, and found a compelling case
-only for the inclusion of <type_traits> in the list of headers required
-of a freestanding implementation.
+We view this as a specific case of issue 952,
+and should be resolved when that issue is resolved.
 
          
 
          
-See Martin Tasker's paper 
-Fixing Freestanding
-which provides the wording to include <type_traits> into freestanding
-implementations.
+Move to NAD.
 
          
 
          
 
@@ -24558,44 +28444,35 @@ implementations.
 
 
          Proposed resolution:
          
 
          
-Add <type_traits> to Table 15.
 
          
 
 
 
 
 
-
 
          
-
          1005. numeric_limits partial specializations not concept enabled
          
-
          Section: 18.3.1.1 [numeric.limits] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all issues with NAD Concepts status.
          
+
          947. duration arithmetic: contradictory requirements
          
+
          Section: 20.9.3.5 [time.duration.nonmember] Status: NAD Editorial
+ Submitter: Pete Becker Opened: 2008-12-20  Last modified: 2009-10-26
          
+
          View all other issues in [time.duration.nonmember].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
-
          Addresses JP 26
          
-
 
          
-numeric_limits [partial specializations] does not use concept.
+In 20.9.3.5 [time.duration.nonmember], paragraph 8 says that calling
+dur / rep
+when rep is an instantiation of duration requires a diagnostic.
+That's followed by an operator/ that takes two durations.
+So dur1 / dur2 is legal under the second version,
+but requires a diagnostic under the first.
 
          
 
 
          [
-Summit:
-]
          
-
-
-
          
-Alisdair will provide a soltion as part of treatment of axioms and LWG 902.
-
          
-
-
          [
-Post Summit:
+Howard adds:
 ]
          
 
 
 
          
-Alisdair recommends NAD as the partial specializations are already
-constrained by requirements on the primary template.
+Please see the thread starting with c++std-lib-22980 for more information.
 
          
 
 
          [
@@ -24603,75 +28480,87 @@ Batavia (2009-05):
 ]
          
 
 
          
-The Working Draft does not in general repeat a primary template's constraints
-in any specializations.
-Move to NAD.
+Move to Open, pending proposed wording (and preferably an implementation).
 
          
 
 
          [
-2009-05-25 Howard adds:
+2009-07-27 Howard adds:
 ]
          
 
 
 
          
-A c++std-lib thread starting at c++std-lib-23880 has cast doubt that NAD is the
-correct resolution of this issue.  Indeed the discussion also casts doubt that
-the current proposed wording is the correct resolution as well.  Personally I'm
-inclined to reset the status to Open.  However I'm reverting the status to 
-that which it had prior to the Batavia recommendation.  I'm setting back to Review.
-
          
-
-
-
          Proposed resolution:
          
 
          
-Change 18.3.1.1 [numeric.limits]:
+I've addressed this issue under the proposed wording for 1177 which
+cleans up several places under 20.9.3 [time.duration] which used the
+phrase "diagnostic required".
+
          
+
          
+For clarity's sake, here is an example implementation of the constrained operator/:
 
          
 
-
          template<class Regular T> class numeric_limits<const T>;
-template<class Regular T> class numeric_limits<volatile T>;
-template<class Regular T> class numeric_limits<const volatile T>;
-
          
-
-
+
          template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
+struct __duration_divide_result
+{
+};
 
+template <class _Duration, class _Rep2,
+    bool = is_convertible<_Rep2,
+                          typename common_type<typename _Duration::rep, _Rep2>::type>::value>
+struct __duration_divide_imp
+{
+};
 
+template <class _Rep1, class _Period, class _Rep2>
+struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
+{
+    typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
+};
 
+template <class _Rep1, class _Period, class _Rep2>
+struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
+    : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
+{
+};
 
-
          
-
          1007. throw_with_nested not concept enabled
          
-
          Section: 18.8.6 [except.nested] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View other active issues in [except.nested].
          
-
          View all other issues in [except.nested].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+template <class _Rep1, class _Period, class _Rep2>
+inline
+typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
+operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+{
+    typedef typename common_type<_Rep1, _Rep2>::type _Cr;
+    duration<_Cr, _Period> __r = __d;
+    __r /= static_cast<_Cr>(__s);
+    return __r;
+}
+
          
 
-
          Addresses JP 29
          
+
          
+__duration_divide_result is basically a custom-built enable_if
+that will contain type only if Rep2 is not a duration
+and if Rep2 is implicitly convertible to
+common_type<typename Duration::rep, Rep2>::type. __is_duration
+is simply a private trait that answers false, but is specialized for
+duration to answer true.
+
          
 
 
          
-throw_with_nested does not use concept.
+The constrained operator% works identically.
 
          
+
          
 
 
          [
-Summit:
+2009-10 Santa Cruz:
 ]
          
 
- 
+
 
          
-Agreed.
+Mark NAD Editorial, fixed by 1177.
 
          
 
 
 
 
          Proposed resolution:
          
-
-
          
-Alisdair initially proposed wording in
-N2619.
-
          
 
          
-We are awaiting an updated paper based on feedback from the San Francisco
-review.
 
          
 
 
@@ -24679,168 +28568,168 @@ review.
 
 
 
          
-
          1010. operator-= should use default in concept
          
-
          Section: 24.2.6 [random.access.iterators] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
-
          View other active issues in [random.access.iterators].
          
-
          View all other issues in [random.access.iterators].
          
-
          View all issues with NAD Concepts status.
          
+
          952. Various threading bugs #2
          
+
          Section: 20.9.3.7 [time.duration.cast] Status: NAD Editorial
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-07-13
          
+
          View all other issues in [time.duration.cast].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
+
          
+20.9.3.7 [time.duration.cast] specifies an implementation and imposes
+requirements in text (and the implementation doesn't satisfy all of the
+text requirements). Pick one.
+
          
+
+
          
+This issue is related to 946.
+
          
+
+
          [
+2009-05-10 Howard adds:
+]
          
 
-
          Addresses UK 263
          
 
+
          
 
          
-This requirement on operator-= would be better expressed as a default
-implementation in the concept, with a matching axiom.
+The Remarks paragraph is an English re-statement of the preceeding
+Returns clause.  It was meant to be clarifying and motivating, not
+confusing.  I'm not aware with how the Remarks contradicts the Returns clause
+but I'm ok with simply removing the Remarks.
 
          
+
          
 
 
          [
 Batavia (2009-05):
 ]
          
 
 
          
-The proposed resolution should also remove
-paragraph 5 and the declaration that precedes it.
-Further, we should provide an axiom
-that captures the desired semantics.
-This may be a broader policy to be applied.
-Move to Open.
+
          
+Pete suggests that this could be resolved
+by rephrasing the Remarks to Notes.
+
          
+
          
+Move to NAD Editorial.
+
          
 
          
 
 
 
          Proposed resolution:
          
 
          
-Change 24.2.6 [random.access.iterators]:
 
          
 
-
          concept RandomAccessIterator<typename X> : BidirectionalIterator<X>, LessThanComparable<X> {
-  ...
-  X& operator-=(X& x, difference_type n) { return x += -n; }
-  ...
-}
-
          
-
-
 
 
 
 
 
          
-
          1013. Response to UK 305
          
-
          Section: 25.5.7 [alg.min.max] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
-
          View all other issues in [alg.min.max].
          
-
          View all issues with NAD Editorial status.
          
+
          955. Various threading bugs #5
          
+
          Section: 20.9.1 [time.clock.req] Status: NAD
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-26
          
+
          View other active issues in [time.clock.req].
          
+
          View all other issues in [time.clock.req].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
-
-
          Addresses UK 305
          
-
 
          
-The negative requirement on IsSameType is a hold-over from an earlier
-draught with a variadic template form of min/max algorith. It is no
-longer necessary.
+20.9.1 [time.clock.req] requires that a clock type have a member
+typedef named time_point that names an instantiation of the
+template time_point, and a member named duration that
+names an instantiation of the template duration. This mixing of
+levels is confusing. The typedef names should be different from the
+template names.
 
          
 
 
          [
-Batavia (2009-05):
+Post Summit, Anthony provided proposed wording.
 ]
          
 
-
          
-We agree with the proposed resolution.
-Move to Tentatively Ready.
-
          
 
 
          [
-2009-07 Frankfurt
+2009-05-04 Howard adds:
 ]
          
 
 
 
          
-We believe this is NAD, but this needs to be reviewed against the
-post-remove-concepts draft.
-
          
-
-
-
-
          Proposed resolution:
          
 
          
-Change 25 [algorithms]:
+The reason that the typedef names were given the same name as the class templates
+was so that clients would not have to stop and think about whether they were
+using the clock's native time_point / duration or the class
+template directly.  In this case, one person's confusion is another person's
+encapsulation.  The detail that sometimes one is referring to the clock's
+native types, and sometimes one is referring to an independent type is
+purposefully "hidden" because it is supposed to be an unimportant
+detail.  It can be confusing to have to remember when to type duration
+and when to type duration_type, and there is no need to require the
+client to remember something like that.
 
          
 
-
          template<class T, StrictWeakOrder<auto, T> Compare>
-  requires !SameType<T, Compare> && CopyConstructible<Compare>
-  const T& min(const T& a, const T& b, Compare comp);
-...
-template<class T, StrictWeakOrder<auto, T> Compare>
-  requires !SameType<T, Compare> && CopyConstructible<Compare>
-  const T& max(const T& a, const T& b, Compare comp);
-...
-template<class T, StrictWeakOrder<auto, T> Compare>
-  requires !SameType<T, Compare> && CopyConstructible<Compare>
-  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
-
          
-
 
          
-Change 25.5.7 [alg.min.max], p1, p9 and p17:
+For example, here is code that I once wrote in testing out the usability of
+this facility:
 
          
 
-
          template<class T, StrictWeakOrder<auto, T> Compare>
-  requires !SameType<T, Compare> && CopyConstructible<Compare>
-  const T& min(const T& a, const T& b, Compare comp);
-...
-template<class T, StrictWeakOrder<auto, T> Compare>
-  requires !SameType<T, Compare> && CopyConstructible<Compare>
-  const T& max(const T& a, const T& b, Compare comp);
-...
-template<class T, StrictWeakOrder<auto, T> Compare>
-  requires !SameType<T, Compare> && CopyConstructible<Compare>
-  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
+
          template <class Clock, class Duration>
+void do_until(const std::chrono::time_point<Clock, Duration>& t)
+{
+    typename Clock::time_point now = Clock::now();
+    if (t > now)
+    {
+        typedef typename std::common_type
+        <
+            Duration,
+            typename std::chrono::system_clock::duration
+        >::type CD;
+        typedef std::chrono::duration<double, std::nano> ID;
+
+        CD d = t - now;
+        ID us = duration_cast<ID>(d);
+        if (us < d)
+            ++us;
+        ...
+    }
+}
 
          
 
-
-
-
-
-
-
          
-
          1015. Response to UK 199
          
-
          Section: 20.2.1 [concept.transform] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all other issues in [concept.transform].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
-
-
          Addresses UK 199
          
-
 
          
-The requirement that programs do not supply concept_maps should
-probably be users do not supply their own concept_map
-specializations. The program will almost certainly supply
-concept_maps - the standard itself supplies a specialization
-for RvalueOf references. Note that the term program is
-defined in 3.5 [basic.link]p1 and makes no account of the
-standard library being treated differently to user written code.
+I see no rationale to require the client to append _type to some
+of those declarations.  It seems overly burdensome on the author of do_until:
 
          
 
-
          [
-2009-05-09 Alisdair adds:
-]
          
-
+
          template <class Clock, class Duration>
+void do_until(const std::chrono::time_point<Clock, Duration>& t)
+{
+    typename Clock::time_point_type now = Clock::now();
+    if (t > now)
+    {
+        typedef typename std::common_type
+        <
+            Duration,
+            typename std::chrono::system_clock::duration_type
+        >::type CD;
+        typedef std::chrono::duration<double, std::nano> ID;
+
+        CD d = t - now;
+        ID us = duration_cast<ID>(d);
+        if (us < d)
+            ++us;
+        ...
+    }
+}
+
          
 
-
          
 
          
-The same problem is present in the words added for the
-LvalueReference/RvalueReference concepts last meeting.
+Additionally I'm fairly certain that this suggestion hasn't been implemented.
+If it had, it would have been discovered that it is incomplete.  time_point
+also has a nested type (purposefully) named duration.
 
          
+
          
+That is, the current proposed wording would put the WP into an inconsistent state.
+
          
 
          
-With three subsections requiring the same constraint, I'm wondering if there
-is a better way to organise this section.
-Possible 20.2.1 -> 20.2.3 belong in the fundamental concepts clause in
-14.10.4 [concept.support]?  While they can be implemented purely as a
-library feature without additional compiler support, they are pretty
-fundamental and we want the same restriction on user-concept maps as is
-mandated there.
+In contrast,
+the current WP has been implemented and I've received very favorable feedback
+from people using this interface in real-world code.
 
          
+
 
          
 
 
          [
@@ -24848,113 +28737,256 @@ Batavia (2009-05):
 ]
          
 
 
          
-We agree with the issue,
-but believe the wording needs further improvement.
-We want to investigate current definitions for nomenclature such as
-"user" and "program."
-Move to Open pending the recommended investigation.
+
          
+Bill agrees that distinct names should be used for distinct kinds of entities.
+
          
+
          
+Walter would prefer not to suffix type names,
+especially for such well-understood terms as "duration".
+
          
+
          
+Howard reminds us that the proposed resolution is incomplete, per his comment
+in the issue.
+
          
+
          
+Move to Open.
+
          
 
          
 
+
          [
+2009-06-07 Howard adds:
+]
          
 
-
          Proposed resolution:
          
-
          
-Change 20.2.1 [concept.transform] p2:
-
          
 
 
          
--2- A program user shall not provide concept maps for
-any concept in 20.1.1.
-
          
-
 
          
-Change 20.2.2 [concept.true] p2:
+Not meaning to be argumentative, but we have a decade of positive experience
+with the precedent of using the same name for the nested type as an external
+class representing an identical concept.
 
          
 
-
          
--2- Requires: a program user shall not
-provide a concept map for the True concept.
-
          
+
          template<class Category, class T, class Distance = ptrdiff_t,
+         class Pointer = T*, class Reference = T&>
+struct iterator
+{
+    ...
+};
+
+template <BidirectionalIterator Iter>
+class reverse_iterator
+{
+    ...
+};
+
+template <ValueType T, Allocator Alloc = allocator<T> >
+    requires NothrowDestructible<T>
+class list
+{
+public:
+    typedef implementation-defined     iterator;
+    ...
+    typedef reverse_iterator<iterator> reverse_iterator;
+    ...
+};
+
          
 
 
          
-Change 20.2.3 [concept.classify] p2:
+I am aware of zero complaints regarding the use of iterator
+and reverse_iterator as nested types of the containers despite these
+names also having related meaning at namespace std scope.
 
          
 
-
          
--2- Requires: a programuser shall not provide concept
-maps for any concept in this section.
-
          
+
          
+Would we really be doing programmers a favor by renaming these nested types?
+
          
 
+
          template <ValueType T, Allocator Alloc = allocator<T> >
+    requires NothrowDestructible<T>
+class list
+{
+public:
+    typedef implementation-defined     iterator_type;
+    ...
+    typedef reverse_iterator<iterator> reverse_iterator_type;
+    ...
+};
+
          
 
+
          
+I submit that such design contributes to needless verbosity which ends up
+reducing readability.
+
          
+
          
 
+
          [
+2009-10 Santa Cruz:
+]
          
 
 
+
          
+Mark as NAD.  No concensus for changing the WP.
+
          
 
-
          
-
          1016. Response to JP 33
          
-
          Section: 20.2.6 [concept.comparison] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all other issues in [concept.comparison].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
 
-
          Addresses JP 33
          
 
+
          Proposed resolution:
          
 
          
-LessThanComparable and EqualityComparable don't correspond to NaN. 
+Change 20.9 [time]:
 
          
 
-
          Original proposed resolution:
          
+
          ...
+template <class Clock, class Duration = typename Clock::duration_type> class time_point;
+...
+
          
 
 
          
-Apply concept_map to these concepts at FloatingPointType.
+Change 20.9.1 [time.clock.req]:
 
          
 
-
          [
-Post Summit, Alisdair adds:
-]
          
+
          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
          Table 45 -- Clock requirements
          ExpressionReturn typeOperational semantics
          .........
          C1::duration_typechrono::duration<C1::rep, C1::period>The native duration type of the clock.
          C1::time_point_typechrono::time_point<C1> or chrono::time_point<C2, C1::duration_type<The native time_point type of the clock.   Different clocks may  share a time_point_type
+definition if it is valid to 
+compare their time_point_types by 
+comparing their respective 
+duration_types. C1 and C2 shall 
+refer to the same epoch.
          .........
          C1::now()C1::time_point_typeReturns a time_point_type object 
+representing the current point 
+in time.
+
          
+
          
 
+
          
+Change 20.9.5.1 [time.clock.system]:
+
          
 
 
          
 
          
-I don't understand the proposed resolution - there is no such thing as a
-'negative' concept_map, and these concepts are auto concepts that match
-float/double etc. Also not clear how we are supposed to match values to
-concepts.
+-1- Objects of class system_clock represent wall clock time from the system-wide realtime clock.
 
          
+
+
          class system_clock { 
+public: 
+  typedef see below rep; 
+  typedef ratio<unspecified, unspecified> period; 
+  typedef chrono::duration<rep, period> duration_type; 
+  typedef chrono::time_point<system_clock> time_point_type; 
+  static const bool is_monotonic = unspecified ; 
+
+  static time_point_type now(); 
+
+  // Map to C API 
+  static time_t to_time_t (const time_point_type& t); 
+  static time_point_type from_time_t(time_t t); 
+};
+
          
+
 
          
-Recommend NAD and treat as a subset of issue 902.
+-2- system_clock::duration_type::min() < system_clock::duration_type::zero() shall be true.
 
          
+
+
          time_t to_time_t(const time_point_type& t);
+
          
+
+
          
+-3- Returns: A time_t object that represents the same
+point in time as t when both values are truncated to the
+coarser of the precisions of time_t and time_point_type.
 
          
 
+
          time_point_type from_time_t(time_t t);
+
          
 
+
          
+-4- Returns: A time_point_type object that represents the same point
+in time as t when both values are truncated to the coarser of the
+precisions of time_t and time_point_type.
+
          
+
          
 
-
          Proposed resolution:
          
 
          
-Recommend NAD.
+Change 20.9.5.2 [time.clock.monotonic]:
 
          
 
+
          class monotonic_clock { 
+public: 
+  typedef unspecified                                rep; 
+  typedef ratio<unspecified , unspecified>           period; 
+  typedef chrono::duration<rep, period>              duration_type; 
+  typedef chrono::time_point<unspecified , duration_type> time_point_type; 
+  static const bool is_monotonic =                   true; 
 
+  static time_point_type now();
+};
+
          
 
+
          
+Change 20.9.5.3 [time.clock.hires]:
+
          
+
+
          class high_resolution_clock { 
+public: 
+  typedef unspecified                                rep; 
+  typedef ratio<unspecified , unspecified>           period; 
+  typedef chrono::duration<rep, period>              duration_type; 
+  typedef chrono::time_point<unspecified , duration_type> time_point_type; 
+  static const bool is_monotonic =                   true; 
+
+  static time_point_type now();
+};
+
          
 
 
-
          
-
          1017. Response to US 66
          
-
          Section: 20.2.11 [concept.regular] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
 
-
          Addresses US 66
          
 
-
          
-Application of the Regular concept to floating-point types appears to be
-controversial (see long discussion on std-lib reflector). 
-
          
 
-
          Original proposed resolution:
          
 
+
          
+
          958. Various threading bugs #8
          
+
          Section: 30.5.1 [thread.condition.condvar] Status: NAD Editorial
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-23
          
+
          View other active issues in [thread.condition.condvar].
          
+
          View all other issues in [thread.condition.condvar].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
 
          
-State that the Regular concept does not apply to floating-point types. 
+30.5.1 [thread.condition.condvar]: the specification for wait_for
+with no predicate has an effects clause that says it calls wait_until,
+and a returns clause that sets out in words how to determine the return
+value. Is this description of the return value subtly different from the
+description of the value returned by wait_until? Or should the effects
+clause and the returns clause be merged?
 
          
 
 
          [
@@ -24963,205 +28995,230 @@ Summit:
 
 
 
          
-
          
-Recommend that we handle the same as JP 33 / 1016.
-
          
+Move to open. Associate with LWG 859 and any other monotonic-clock
+related issues.
 
          
 
 
          [
-Post Summit, Alisdair adds:
+2009-08-01 Howard adds:
 ]
          
 
 
 
          
-
          
-Recommend Open, and review after resolution of 902 and revised axiom
-feature.
-
          
+I believe that 859 (currently Ready) addresses this issue, and
+that this issue should be marked NAD, solved by 859 (assuming
+it moves to WP).
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD Editorial, solved by resolution of Issue 859.
 
          
 
 
 
 
          Proposed resolution:
          
+
          
+
          
 
 
 
 
 
 
          
-
          1018. Response to US 70
          
-
          Section: 20.6 [meta] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View other active issues in [meta].
          
-
          View all other issues in [meta].
          
-
          View all issues with NAD Concepts status.
          
+
          961. Various threading bugs #11
          
+
          Section: 30.4.1 [thread.mutex.requirements] Status: NAD Future
+ Submitter: Pete Becker Opened: 2009-01-07  Last modified: 2009-10-26
          
+
          View other active issues in [thread.mutex.requirements].
          
+
          View all other issues in [thread.mutex.requirements].
          
+
          View all issues with NAD Future status.
          
+
          Duplicate of: 936
          
 
          Discussion:
          
-
-
          Addresses US 70
          
-
 
          
-Specifications now expressed via narrative text are more accurately and
-clearly expressed via executable code.
-
          
-
          
-Wherever concepts are available that directly match this section's type
-traits, express the traits in terms of the concepts instead of via
-narrative text. Where the type traits do not quite match the
-corresponding concepts, bring the two into alignment so as to avoid two
-nearly-identical notions.
+30.4.1 [thread.mutex.requirements] describes required member
+functions of mutex types, and requires that they throw exceptions under
+certain circumstances. This is overspecified. User-defined types can
+abort on such errors without affecting the operation of templates
+supplied by standard-library.
 
          
 
 
          [
 Summit:
 ]
          
 
+
          
+Move to open. Related to conceptualization and should probably be
+tackled as part of that.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
 
 
          
 
          
-We think that this is a good idea, but it requires a lot of work. If someone
-submits a paper proposing specific changes, we would be happy to review it
-at the next meeting.
+Would be OK to leave it as is for time constraints, could loosen later.
+
          
+
+
          
+Mark as NAD Future.
 
          
 
          
 
 
 
 
          Proposed resolution:
          
+
          
+
          
 
 
 
 
 
 
          
-
          1022. Response to UK 212
          
-
          Section: 20.8.10.7 [util.dynamic.safety] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-03-12
          
-
          View all other issues in [util.dynamic.safety].
          
+
          969. What happened to Library Issue 475?
          
+
          Section: 25.2.4 [alg.foreach] Status: NAD Editorial
+ Submitter: Stephan T. Lavavej Opened: 2009-01-12  Last modified: 2009-07-13
          
+
          View all other issues in [alg.foreach].
          
 
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
-
          Addresses UK 212
          
-
 
          
-The pointer-safety API is nothing to do with smart pointers, so does not
-belong in 20.8.10 [util.smartptr]. In fact it is a set of language
-support features are really belongs in clause 18 [language.support], with the contents declared in a header that
-deals with language-support of memory management.
+Library Issue 475 has CD1 status, but the non-normative note in
+N2723
+was removed in
+N2798
+(25.2.4 [alg.foreach] in both drafts).
 
          
 
 
          [
-Summit:
+Batavia (2009-05):
 ]
          
 
-
 
          
-Agree in principle, but not with the proposed resolution. We believe it
-belongs either a subsection of either 20 [utilities] or 20.8 [memory]
-as part of the general reorganization of 20 [utilities]. The
-declaration should stay in
-<memory>.
+Move to NAD Editorial.
 
          
 
 
-
 
          Proposed resolution:
          
+
          
+Restore the non-normative note. It might need to be expressed in terms of concepts.
+
          
 
 
 
 
 
 
          
-
          1023. Response to DE 22
          
-
          Section: 20.7.16.2 [func.wrap.func] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-13
          
-
          View all other issues in [func.wrap.func].
          
-
          View all issues with NAD Editorial status.
          
+
          971. Spurious diagnostic conversion function
          
+
          Section: 19.5.2.5 [syserr.errcode.nonmembers] Status: NAD
+ Submitter: Beman Dawes Opened: 2009-01-19  Last modified: 2009-10-20
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
-
-
          Addresses DE 22
          
-
-
          Related to issue 1114.
          
-
 
          
-The conditions for deriving from std::unary_function and
-std::binary_function are unclear: The condition would also be satisfied if
-ArgTypes were std::vector<T1>, because it (arguably)
-"contains" T1.
+Anthony Williams raised the question in c++std-lib-22987 "why is there
+std::make_error_code(std::errc)? What purpose does this serve?"
+
          
+
          
+The function make_error_code(errc e) is not required, since
+make_error_condition(errc e) is the function that is needed for errc
+conversions. make_error_code(errc e) appears to be a holdover from my
+initial confusion over the distinction between POSIX and operating
+systems that conform to the POSIX spec.
 
          
 
 
          [
-Summit:
+Post Summit:
 ]
          
 
 
 
          
-Agree. std::reference_wrapper has the same structure, and we
-suggest that std::function be presented in the same way as
-std::reference_wrapper.
+Recommend Review.
 
          
 
 
          [
-2009-05-09 Alisdair adds:
+Batavia (2009-05):
 ]
          
 
-
 
          
-Phrasing should be "publicly and
-unambiguously derived from" and probably back in reference_wrapper too.  Updated
-wording supplied.
+The designer of the facility (Christopher Kohlhoff)
+strongly disagrees that there is an issue here,
+and especially disagrees with the proposed resolution.
+Bill would prefer to be conservative and not apply this proposed resolution.
+Move to Open, and recommend strong consideration for NAD status.
 
          
 
 
          [
-Batavia (2009-05):
+2009-05-21 Beman adds:
 ]
          
 
+
 
          
-We agree with the proposed wording.
-Move to NAD Editorial.
+My mistake. Christopher and Bill are correct and the issue should be
+NAD. The function is needed by users.
 
          
 
+
          [
+2009-07-21 Christopher Kohlhoff adds rationale for make_error_code:
+]
          
+
 
-
          Proposed resolution:
          
+
          
 
          
-(no changes to <functional> synopsis required)
-
          
-
-
          
-Change synopsis in Class template function 20.7.16.2 [func.wrap.func]:
+Users (and indeed library implementers) may need to use the
+errc codes in portable code. For example:
 
          
 
-
          template<Returnable R, CopyConstructible... ArgTypes> 
-class function<R(ArgTypes...)> 
-  : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and see below
-                                      // ArgTypes contains T1
-  : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and see below
-                                      // ArgTypes contains T1 and T2
+
          void do_foo(error_code& ec)
 {
-   ...
+#if defined(_WIN32)
+  // Windows implementation ...
+#elif defined(linux)
+  // Linux implementation ...
+#else
+  // do_foo not supported on this platform
+  ec = make_error_code(errc::not_supported);
+#endif
+}
 
          
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
 
+
+
          
+Moved to NAD.
+
          
+
+
+
+
          Proposed resolution:
          
 
          
-Add new p1/p2 before 20.7.16.2.1 [func.wrap.func.con]:
+Change System error support 19.5 [syserr], Header <system_error>
+synopsis, as indicated:
 
          
 
-
          
-
          
-The template instantiation function<R(T1)> shall be publicly and
-unambiguously derived from 
-std::unary_function<T1,R> if and only if the template type parameter
-is a function type taking one argument of type T1 and returning R.
-
          
+
          error_code make_error_code(errc e);
+error_condition make_error_condition(errc e);
+
          
 
-
          
-The template instantiation function<R(T1,T2)> shall be publicly and
-unambiguously derived from 
-std::binary_function<T1,T2,R> if and only if the template type
-parameter is a function type taking two arguments of type T1 and T2 and
-returning R.
-
          
+
          
+Delete from Class error_code non-member functions
+19.5.2.5 [syserr.errcode.nonmembers]:
+
          
 
-
          explicit function();
+
          error_code make_error_code(errc e);
 
          
+
          
+Returns: error_code(static_cast<int>(e),
+generic_category).
+
          
 
          
 
 
@@ -25170,67 +29227,93 @@ returning R.
 
 
 
          
-
          1024. Response to JP 39
          
-
          Section: 20.7.16.2 [func.wrap.func] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
-
          View all other issues in [func.wrap.func].
          
-
          View all issues with NAD Concepts status.
          
+
          972. The term "Assignable" undefined but still in use
          
+
          Section: 17 [library] Status: NAD Editorial
+ Submitter: Niels Dekker Opened: 2009-01-07  Last modified: 2009-07-13
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
-
          Addresses JP 39
          
-
 
          
-There are no requires corresponding to F of std::function.
+Previous versions of the Draft had a table, defining the Assignable 
+requirement.  For example 
+N2134
+Table 79, "Assignable requirements". But I guess the term "Assignable" 
+is outdated by now, because the current Committee Draft provides 
+MoveAssignable, CopyAssignable, and TriviallyCopyAssignable concepts 
+instead. And as far as I can see, it no longer has a definition of 
+Assignable. (Please correct me if I'm wrong.) Still the word 
+"Assignable" is used in eight places in the Draft, 
+N2800.
 
          
 
-
          [
-2009-05-01 Daniel adds:
-]
          
-
-
-
          
-1070 removes the second constructor.
-
          
+
          
+Are all of those instances of "Assignable" to be replaced by "CopyAssignable"? 
+
          
 
 
          [
 Batavia (2009-05):
 ]
          
 
 
          
-We agree with the proposed resolution.
-Move to Tentatively Ready.
-If issue 1070 is accepted,
-the changes to the second constructor
-in this issue are moot.
+Move to NAD Editorial.
 
          
 
-
          [
-2009-07 Frankfurt:
-]
          
 
+
          Proposed resolution:
          
 
+
          
+Change Exception Propagation 18.8.5 [propagation]:
+
          
 
          
-Constructors have no definition.
+exception_ptr shall be DefaultConstructible, CopyConstructible,
+CopyAssignable and EqualityComparable.
 
          
 
-
-
-
          Proposed resolution:
          
 
          
-Correct as follows in 20.7.16.2 [func.wrap.func] (class definition)
+Change Class template reference_wrapper 20.7.5 [refwrap]:
+
          
+
          
+reference_wrapper<T> is a CopyConstructible and CopyAssignable wrapper around a reference to an object of type T.
+
          
+
          
+Change Placeholders 20.7.11.1.4 [func.bind.place]:
+
          
+
          
+It is implementation defined whether placeholder types are CopyAssignable. CopyAssignable placeholders' copy assignment operators shall not throw exceptions.
+
          
+
          
+Change Class template shared_ptr 20.8.15.2 [util.smartptr.shared]:
+
          
+
          
+Specializations of shared_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable...
+
          
+
          
+Change Class template weak_ptr 20.8.15.3 [util.smartptr.weak]:
+
          
+
          
+Specializations of weak_ptr shall be CopyConstructible, CopyAssignable, and LessThanComparable...
+
          
+
          
+Change traits typedefs 21.2.2 [char.traits.typedefs] (note: including deletion of reference to 23.1!):
+
          
+
          
+Requires: state_type shall meet the requirements of CopyAssignable (23.1), CopyConstructible (20.1.8), and DefaultConstructible types.
+
          
+
          
+Change Class seed_seq 26.5.7.1 [rand.util.seedseq] (note again: including deletion of reference to 23.1!):
 
          
+
          
+In addition to the requirements set forth below, instances of
+seed_seq shall meet the requirements of CopyConstructible (20.1.8) and of CopyAssignable (23.1).
+
          
 
-
           template<class F, Allocator Alloc>
-   requires ConstructibleWithAllocator<F, Alloc>
-     && call=Callable<F, ArgTypes...>
-     && Convertible<call::result_type, R>
-   function(allocator_arg_t, const Alloc&, F);
- template<class F, Allocator Alloc>
-   requires ConstructibleWithAllocator<F,Alloc>
-     && call=Callable<F, ArgTypes...>
-     && Convertible<call::result_type, R>
-   function(allocator_arg_t, const Alloc&, F&&);
-
          
+
          
+Note: The proposed resolution of this issue does not deal with the
+instance of the term "Assignable" in D.10.1 [auto.ptr], as this is dealt
+with more specifically by LWG 973, "auto_ptr characteristics", submitted
+by Maarten Hilferink.
+
          
 
 
 
@@ -25238,428 +29321,452 @@ Correct as follows in 20.7.16.2 [func.wrap.func] (class definition)
 
 
 
          
-
          1025. Response to UK 208
          
-
          Section: 20.7.17 [unord.hash] Status: NAD Future
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-03-12
          
-
          View other active issues in [unord.hash].
          
-
          View all other issues in [unord.hash].
          
-
          View all issues with NAD Future status.
          
+
          973. auto_ptr characteristics
          
+
          Section: D.10.1 [auto.ptr] Status: NAD Editorial
+ Submitter: Maarten Hilferink Opened: 2009-01-21  Last modified: 2009-07-13
          
+
          View all other issues in [auto.ptr].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
-
          Addresses UK 208
          
-
 
          
-std::hash should be implemented for much more of the standard
-library. In particular for pair, tuple and all the
-standard containers.
+I think that the Note of D.10.1 [auto.ptr], paragraph 3 needs a rewrite 
+since "Assignable" is no longer defined as a concept. 
+The relationship of auto_ptr with the new CopyAssignable, MoveAssignable,
+ and MoveConstructible concepts should be clarified.
+Furthermore, since the use of auto_ptr is depreciated anyway,
+ we can also omit a description of its intended use.
 
          
 
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We agree with the intent of the proposed resolution.
+Move to NAD Editorial.
+
          
 
 
 
          Proposed resolution:
          
+
          
+Change D.10.1 [auto.ptr], paragraph 3:
+
          
+
+
          
+The auto_ptr provides a semantics of strict ownership. An
+auto_ptr owns the ob ject it holds a pointer to. Copying an
+auto_ptr copies the pointer and transfers ownership to the
+destination. If more than one auto_ptr owns the same ob ject at
+the same time the behavior of the program is undefined. [Note:
+The uses of auto_ptr include providing temporary
+exception-safety for dynamically allocated memory, passing ownership of
+dynamically allocated memory to a function, and returning dynamically
+allocated memory from a function.
+auto_ptr does not meet the
+CopyConstructible and Assignable requirements for
+standard library container elements and thus instantiating a standard
+library container with an auto_ptr results in undefined
+behavior.
+
+Instances of auto_ptr shall
+meet the MoveConstructible and MoveAssignable
+requirements, but do not meet the CopyConstructible and
+CopyAssignable requirements.
+-- end note]
+
          
 
 
 
 
 
 
          
-
          1026. Response to UK 209
          
-
          Section: 20.8 [memory] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all other issues in [memory].
          
-
          View all issues with NAD Concepts status.
          
+
          976. Class template std::stack should be movable
          
+
          Section: 23.3.5.3.1 [stack.defn] Status: NAD Editorial
+ Submitter: Daniel Krügler Opened: 2009-02-01  Last modified: 2009-10-20
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
+
          
+The synopsis given in 23.3.5.3.1 [stack.defn] does not show up
+
          
 
-
          Addresses UK 209
          
+
          requires MoveConstructible<Cont> stack(stack&&);
+requires MoveAssignable<Cont> stack& operator=(stack&&);
+
          
 
 
          
-Smart pointers cannot be used in constrained templates.
+although the other container adaptors do provide corresponding
+members.
 
          
 
 
          [
-Summit:
+Batavia (2009-05):
 ]
          
 
-
 
          
-We look forward to a paper on this topic. We recommend no action until a
-paper is available. We understand that a paper is forthcoming.
+
          
+We agree with the proposed resolution.
+
          
+
          
+Move to Tentatively Ready.
+
          
 
          
 
 
          [
-Peter Dimov adds:
+2009-07 Frankfurt
 ]
          
 
 
 
          
-shared_ptr<T> and weak_ptr<T> support all
-types T for which T* is valid. In other words, a
-possible (partial) resolution is to change class T to
-PointeeType T for shared_ptr, weak_ptr and
-possibly enable_shared_from_this.
+Moved from Tentatively Ready to Open only because the wording needs to be
+tweaked for concepts removal.
 
          
 
+
          [
+2009-08-18 Daniel updates the wording and Howard sets to Review.
+]
          
 
 
-
          Proposed resolution:
          
+
          [
+2009-08-23 Howard adds:
+]
          
 
 
+
          
+1194 also adds these move members using an editorially different
+style.
+
          
 
+
          [
+2009-10 Santa Cruz:
+]
          
 
 
-
          
-
          1027. Response to UK 213
          
-
          Section: 20.8.4 [default.allocator] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
          
+Mark NAD Editorial, solved by issue 1194.
+
          
 
-
          Addresses UK 213
          
 
-
          
-std::allocator should be constrained to simplify its use on constrained
-contexts. This library component models allocation from free store via the
-new operator so choose constraints to 
-match. The Allocator concept allows for a wider variety of allocators that
-users may choose to supply if their allocation model does not require
-operator new, without impacting the 
-requirements of this template. 
-
          
 
+
          Proposed resolution:
          
 
          
-Suggested direction:
+In the class stack synopsis of 23.3.5.3.1 [stack.defn] insert:
 
          
-
          
-The primary allocator template should be constrained to require
-ObjectType<T> and FreeStoreAllocatable<T>.
-Further operations to be constrained as required.
-
          
-
-
          [
-Summit:
-]
          
-
 
-
          
-Agree as stated. A future paper will address additional related issues.
-
          
+
          template <class T, class Container = deque<T> >
+class stack {
+  [..]
+  explicit stack(const Container&);
+  explicit stack(Container&& = Container());
+  stack(stack&& s) : c(std::move(s.c)) {}
+  stack& operator=(stack&& s) { c = std::move(s.c); return *this; }
+  [..]
+};
+
          
 
 
 
-
          Proposed resolution:
          
 
 
 
 
 
 
          
-
          1028. Response to UK 214
          
-
          Section: 20.8.6 [storage.iterator] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
-
          View all issues with NAD Concepts status.
          
+
          977. insert iterators inefficient for expensive to move types
          
+
          Section: 24.5.2 [insert.iterators] Status: NAD
+ Submitter: Howard Hinnant Opened: 2009-02-02  Last modified: 2009-10-26
          
+
          View all other issues in [insert.iterators].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
+
          
+The new concepts for the insert iterators mandate an extra copy when
+inserting an lvalue:
+
          
 
-
          Addresses UK 214
          
+
          requires CopyConstructible<Cont::value_type>
+  back_insert_iterator<Cont>& 
+  operator=(const Cont::value_type& value);
+
          
+
          
+-1- Effects: push_back(*container, Cont::value_type(value));
+
          
+
          
 
 
          
-raw_storage_iterator needs constraining as an iterator adaptor to be safely
-used in constrained templates 
+The reason is to convert value into an rvalue because the current
+BackInsertionContainer concept only handles push_back-ing
+rvalues:
 
          
 
-
          [
-Summit:
-]
          
+
          concept BackInsertionContainer<typename C> : Container<C> { 
+  void push_back(C&, value_type&&); 
+}
+
          
+
+
          
+Without the conversion of value to an rvalue, the assignment operator
+fails to concept check.
+
          
+
+
          
+A solution is to modify the BackInsertionContainer concept so that
+the client can pass in the parameter type for push_back similar to
+what is already done for the OutputIterator concept:
+
          
+
+
          concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
+  : Container<C> { 
+     void push_back(C&, Value); 
+}
+
          
 
+
          
+This allows the assignment operator to be adjusted appropriately:
+
          
 
+
          requires BackInsertionContainer<Cont, Cont::value_type const&> &&
+         CopyConstructible<Cont::value_type>
+  back_insert_iterator<Cont>& 
+  operator=(const Cont::value_type& value);
+
          
 
          
-We look forward to a paper on this topic. We recommend no action until a
-paper is available.
+-1- Effects: push_back(*container, value);
+
          
 
          
 
 
          [
-Post Summit Alisdair provided wording and rationale.
+We may want to propagate this fix to other concepts such as StackLikeContainer.
 ]
          
 
 
+
          [
+Solution and wording collaborated on by Doug and Howard.
+]
          
 
 
-
          Proposed resolution:
          
-
          
-20.8 [memory] p2
-
          
+
          [
+Batavia (2009-05):
+]
          
+
+
          
 
          
-Update the synopsis for <memory>
+Howard notes that "these operations behaved efficiently until concepts were added."
 
          
-
          // 20.7.8, raw storage iterator:
-template <class ForwardIterator OutputIterator, class ObjectType T> 
-  requires OutputIterator< OutIter, T >
-    class raw_storage_iterator;
-
-template <ForwardIterator OutIter, ObjectType T> 
-  requires OutputIterator< OutIter, T >
-  concept_map Iterator<raw_storage_iterator< OutIter, T > > { }
-
          
-
-
 
          
-20.8.6 [storage.iterator] p1
+Alisdair is uncertain that the proposed resolution is syntactically correct.
 
          
 
          
-Replace class template definition with:
+Move to Open, and recommend the issue be deferred until after the next
+Committee Draft is issued.
 
          
-
          namespace std { 
-  template <class ForwardIterator OutputIterator, class ObjectType T> 
-    requires OutputIterator< OutIter, T >
-  class raw_storage_iterator 
-    : public iterator<output_iterator_tag,void,void,void,void> { 
-  public: 
-    explicit raw_storage_iterator(OutputIterator x); 
+
          
 
-    raw_storage_iterator<OutputIterator,T>& operator*(); 
-    raw_storage_iterator<OutputIterator,T>& operator=(const T& element); 
-    raw_storage_iterator<OutputIterator,T>& operator++(); 
-    raw_storage_iterator<OutputIterator,T> operator++(int); 
-  }; 
+
          [
+2009-10 Santa Cruz:
+]
          
 
-  template <ForwardIterator OutIter, ObjectType T> 
-    requires OutputIterator< OutIter, T >
-    concept_map Iterator<raw_storage_iterator< OutIter, T > > { }
-}
-
          
 
+
          
+NAD, solved by the removal of concepts.
+
          
 
-
          Rationale:
          
+
+
+
          Proposed resolution:
          
 
          
-raw_storage_iterator has to adapt a ForwardIterator,
-rather than just an InputIterator for two reasons:
+Change  [container.concepts.free]:
 
          
 
-
            
-
          1. 
-The initial iterator passed by value is expected to remain valid,
-pointing to the initialized region of memory.
-
            2. 
-
          2. 
-to avoid breaking the declaration of post-increment operator which would
-require some kind of proxy formulation to support generalised InputIterators.
-
            3. 
-
          
-
+
          
+
          concept FrontInsertionContainer<typename C, typename Value = C::value_type&&>
+    : Container<C> { 
+  void push_front(C&, value_type&& Value); 
 
+  axiom FrontInsertion(C c, value_type Value x) { 
+    x == (push_front(c, x), front(c)); 
+  } 
+}
+
          
 
+
          ...
          
 
+
          concept BackInsertionContainer<typename C, typename Value = C::value_type&&>
+    : Container<C> { 
+  void push_back(C&, value_type&& Value); 
+}
+
          
 
+
          ...
          
 
-
          
-
          1029. Response to UK 210
          
-
          Section: 20.8.8 [specialized.algorithms] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
-
          View all other issues in [specialized.algorithms].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
          concept InsertionContainer<typename C, typename Value = C::value_type&&>
+    : Container<C> { 
+  iterator insert(C&, const_iterator, value_type&& Value); 
 
-
          Addresses UK 210
          
+  axiom Insertion(C c, const_iterator position, value_type Value v) { 
+    v == *insert(c, position, v); 
+  } 
+}
+
          
 
-
          Related to 582
          
+
          
 
 
          
-Specialized algorithms for memory managenment need requirements to be
-easily usable in constrained templates.
+Change  [container.concepts.member]:
 
          
 
-
          [
-Summit:
-]
          
-
-
 
          
-We look forward to a paper on this topic. We recommend no action until a
-paper is available.
-
          
+
          auto concept MemberFrontInsertionContainer<typename C, typename Value = C::value_type&&>
+    : MemberContainer<C> { 
+  void C::push_front(value_type&& Value); 
 
-
          [
-Post Summit Alisdair provided wording.
-]
          
+  axiom MemberFrontInsertion(C c, value_type Value x) { 
+    x == (c.push_front(x), c.front()); 
+  } 
+}
+
          
 
+
          ...
          
 
-
          [
-Post Summit:
-]
          
+
          auto concept MemberBackInsertionContainer<typename C, typename Value = C::value_type&&>
+    : MemberContainer<C> { 
+  void C::push_back(value_type&& Value); 
+}
+
          
 
+
          ...
          
 
-
          
-
          
-Daniel adds:
-
          
+
          auto concept MemberInsertionContainer<typename C, typename Value = C::value_type&&>
+    : MemberContainer<C> { 
+  iterator C::insert(const_iterator, value_type&& Value); 
 
-
          
-
            
-
          1. 
-I suggest Size should require IntegralLike and not UnsignedIntegralLike,
-because otherwise simple int-literals could not be provided as arguments
-and it would conflict with other algorithms that only require IntegralLike.
-
            2. 
-
          2. 
-
            
-The current for-loop-test relies on evaluation in boolean context which is
-not provided by ArithmeticLike and it's refinements. I propose to change the
-corresponding for-loop-headers to:
-
            
-
              
-
            1. 
-for uninitialized_copy_n: for ( ; n > Size(0); ++result, ++first, --n) {
-
              2. 
-
            2. 
-for uninitialized_fill_n: for (; n > Size(0); ++first, --n) {
-
              3. 
-
            
-
            3. 
-
          
+  axiom MemberInsertion(C c, const_iterator position, value_type Value v) { 
+    v == *c.insert(position, v); 
+  } 
+}
+
          
 
          
 
 
          
-Alisdair adds:
+Change  [container.concepts.maps]:
 
          
+
 
          
-For the record I agree with Daniel's suggestion.
-
          
+
          template <MemberFrontInsertionContainer C, typename Value = C::value_type&&> 
+concept_map FrontInsertionContainer<C, Value> { 
+  typedef Container<C>::value_type value_type;
 
-
          
+  void push_front(C& c, value_type&& Value v) { c.push_front(static_cast<value_type&& Value>(v)); } 
+}
+
          
 
+
          ...
          
 
+
          template <MemberBackInsertionContainer C, typename Value = C::value_type&&> 
+concept_map BackInsertionContainer<C, Value> { 
+  typedef Container<C>::value_type value_type;
 
-
          Proposed resolution:
          
-
          
-20.8 [memory] p2
-
          
-
          
-Update the synopsis for <memory>
-
          
-
          template <class InputIterator InIter,
-         class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
-   requires ForwardIterator<OutIter>
-   ForwardIterator OutIter
-   uninitialized_copy(InputIterator InIter first, InputIterator InIter last, 
-                      ForwardIterator OutIter result);
+  void push_back(C& c, value_type&& Value v) { c.push_back(static_cast<value_type&& Value>(v)); } 
+}
+
          
 
-template <class InputIterator InIter,
-          class IntegralLike Size,
-          class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
-  requires ForwardIterator<OutIter>
-  ForwardIterator OutIter
-  uninitialized_copy_n(InputIterator InIter first, Size n, 
-                       ForwardIterator OutIter result);
+
          ...
          
 
-template <class ForwardIterator Iter, class ObjectType T>
-  requires Constructible< Iter::value_type, const T& >
-  void uninitialized_fill(ForwardIterator Iter first, ForwardIterator Iter last, 
-                          const T& x);
+
          template <MemberInsertionContainer C, typename Value = C::value_type&&> 
+concept_map InsertionContainer<C, Value> { 
+  typedef Container<C>::value_type value_type;
+  Container<C>::iterator insert(C& c, Container<C>::const_iterator i, value_type&& Value v) 
+  { return c.insert(i, static_cast<value_type&& Value>(v)); } 
+}
+
          
 
-template <class ForwardIterator Iter, class IntegralLike Size, class ObjectType T> 
-  requires Constructible< Iter::value_type, const T& >
-  void
-  uninitialized_fill_n(ForwardIterator Iter first, Size n, const T& x);
-
          
+
          
 
 
          
-Update as follows:
+Change 24.5.2.1 [back.insert.iterator]:
 
          
 
+
          template <BackInsertionContainer Cont> 
+class back_insert_iterator {
+  ...
+  requires BackInsertionContainer<Cont, const Cont::value_type&>
+           CopyConstructible<Cont::value_type>
+    back_insert_iterator<Cont>& 
+      operator=(const Cont::value_type& value);
+  ...
+
          
+
 
          
-uninitialized_copy 20.8.8.2 [uninitialized.copy]
+Change 24.5.2.2.2 [back.insert.iter.op=]:
 
          
 
-
          template <class InputIterator InIter,
-         class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
-   requires ForwardIterator<OutIter>
-   ForwardIterator OutIter
-   uninitialized_copy(InputIterator InIter first, InputIterator InIter last, 
-                      ForwardIterator OutIter result);
+
          
+
          requires BackInsertionContainer<Cont, const Cont::value_type&>
+         CopyConstructible<Cont::value_type>
+  back_insert_iterator<Cont>& 
+    operator=(const Cont::value_type& value);
 
          
-
 
          
+-1- Effects: push_back(*container, Cont::value_type(value));
+
          
+
          
+
 
          
--1- Effects:
+Change 24.5.2.3 [front.insert.iterator]:
 
          
-
          for (; first != last; ++result, ++first)  {
-   new (static_cast<void*>(&*result))
-       typename iterator_traits<ForwardIterator> OutIter::value_type(*first);
-}
+
+
          template <FrontInsertionContainer Cont> 
+class front_insert_iterator {
+  ...
+  requires FrontInsertionContainer<Cont, const Cont::value_type&>
+           CopyConstructible<Cont::value_type>
+    front_insert_iterator<Cont>& 
+      operator=(const Cont::value_type& value);
+  ...
 
          
 
 
          
--2- Returns: result
+Change 24.5.2.4.2 [front.insert.iter.op=]:
 
          
 
+
          
+
          requires FrontInsertionContainer<Cont, const Cont::value_type&>
+         CopyConstructible<Cont::value_type>
+  front_insert_iterator<Cont>& 
+    operator=(const Cont::value_type& value);
+
          
+
          
+-1- Effects: push_front(*container, Cont::value_type(value));
+
          
 
          
-
-
          template <class InputIterator InIter,
-          class IntegralLike Size,
-          class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
-  requires ForwardIterator<OutIter>
-  ForwardIterator OutIter
-  uninitialized_copy_n(InputIterator InIter first, Size n, 
-                       ForwardIterator OutIter result);
-
          
-
-
          
-
          
--3- Effects:
-
          
-
          for ( ; n > Size(0); ++result, ++first, --n) {
-   new (static_cast<void*>(&*result))
-       typename iterator_traits<ForwardIterator> OutIter::value_type(*first);
-}
-
          
-
          
--4- Returns: result
-
          
-
          
-
-
          
-
 
 
          
-uninitialized_fill 20.8.8.3 [uninitialized.fill]
+Change 24.5.2.5 [insert.iterator]:
 
          
 
-
          template <class ForwardIterator Iter, class ObjectType T>
-  requires Constructible< Iter::value_type, const T& >
-  void uninitialized_fill(ForwardIterator Iter first, ForwardIterator Iter last, 
-                          const T& x);
-
          
-
-
          
-
          
--1- Effects:
-
          
-
          for (; first != last; ++first) {
-   new ( static_cast<void*>( &*first) ) 
-       typename iterator_traits<ForwardIterator> Iter::value_type(x);
-}
+
          template <InsertionContainer Cont> 
+class insert_iterator {
+  ...
+  requires InsertionContainer<Cont, const Cont::value_type&>
+           CopyConstructible<Cont::value_type>
+    insert_iterator<Cont>& 
+      operator=(const Cont::value_type& value);
+  ...
 
          
-
          
-
          
-
 
 
          
-uninitialized_fill_n 20.8.8.4 [uninitialized.fill.n]
+Change 24.5.2.6.2 [insert.iter.op=]:
 
          
 
-
          template <class ForwardIterator Iter, class IntegralLike Size, class ObjectType T> 
-  requires Constructible< Iter::value_type, const T& >
-  void
-  uninitialized_fill_n(ForwardIterator Iter first, Size n, const T& x);
+
          
+
          requires InsertionContainer<Cont, const Cont::value_type&>
+         CopyConstructible<Cont::value_type>
+  insert_iterator<Cont>& 
+    operator=(const Cont::value_type& value);
 
          
-
 
          
 
          
 -1- Effects:
 
          
-
          for (; n-- > Size(0); ++first, --n) {
-   new ( static_cast<void*>( &*first) ) 
-       typename iterator_traits<ForwardIterator> Iter::value_type(x);
-}
+
          iter = insert(*container, iter, Cont::value_type(value)); 
+++iter;
 
          
 
          
 
          
@@ -25670,357 +29777,350 @@ uninitialized_fill_n 20.8.8.4 [uninitialized.fill.n]
 
 
 
          
-
          1032. Response to JP 45
          
-
          Section: 20.9 [time] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
-
          View all other issues in [time].
          
-
          View all issues with NAD Concepts status.
          
+
          979. Bad example
          
+
          Section: 24.5.3 [move.iterators] Status: NAD Editorial
+ Submitter: Howard Hinnant Opened: 2009-02-03  Last modified: 2009-07-13
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
+
          
+24.5.3 [move.iterators] has an incorrect example:
+
          
 
-
          Addresses JP 45
          
-
+
          
 
          
-Rep, Period, Clock and Duration
-don't correspond to concept.
+-2- [Example:
 
          
-
          template <class Rep, class Period = ratio<1>> class duration; 
-template <class Clock, class Duration = typename Clock::duration> class time_point; 
+
+
          set<string> s; 
+// populate the set s 
+vector<string> v1(s.begin(), s.end());          // copies strings into v1 
+vector<string> v2(make_move_iterator(s.begin()), 
+                  make_move_iterator(s.end())); // moves strings into v2
 
          
+
 
          
-Make concept for Rep, Period, Clock and Duration.
-Fix 20.9 [time] and wait_until
-and wait_for's template parameter at 30 [thread]. 
+-- end example]
+
          
+
          
+
+
          
+One can not move from a set because the iterators return const
+references.
 
          
 
 
          [
-Summit:
+Batavia (2009-05):
 ]
          
 
-
 
          
-We agree that this section needs concepts. We look forward to a paper on
-this topic. We recommend no action until a paper is available.
+We agree with the proposed resolution. Move to NAD Editorial.
 
          
 
 
 
 
          Proposed resolution:
          
+
          
+Change 24.5.3 [move.iterators]/2:
+
          
+
+
          
+
          
+-2- [Example:
+
          
+
+
          setlist<string> s; 
+// populate the setlist s 
+vector<string> v1(s.begin(), s.end());          // copies strings into v1 
+vector<string> v2(make_move_iterator(s.begin()), 
+                  make_move_iterator(s.end())); // moves strings into v2
+
          
+
+
          
+-- end example]
+
          
+
          
 
 
 
 
 
 
          
-
          1036. Response to UK 231
          
-
          Section: 23.2.3 [sequence.reqmts] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-15
          
-
          View all other issues in [sequence.reqmts].
          
-
          View all issues with NAD Concepts status.
          
+
          980. mutex lock() missing error conditions
          
+
          Section: 30.4.1 [thread.mutex.requirements] Status: NAD
+ Submitter: Ion Gaztańaga Opened: 2009-02-07  Last modified: 2009-03-22
          
+
          View other active issues in [thread.mutex.requirements].
          
+
          View all other issues in [thread.mutex.requirements].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
+
          
+POSIX 2008 adds two return values for pthread_mutex_xxxlock():
+EOWNERDEAD (owner_dead) and ENOTRECOVERABLE
+(state_not_recoverable). In the first case the mutex is locked,
+in the second case the mutex is not locked.
+
          
 
-
          Addresses UK 231
          
+
          
+Throwing an exception in the first case can be incompatible with the use
+of Locks, since the Lock::owns_lock() will be false when the lock is
+being destroyed.
+
          
 
 
          
-p9-p11 are redundant now that Concepts define what it means to be an
-Iterator and guide overload resolution accordingly. 
+Consider:
+
          
+
+
          //Suppose mutex.lock() throws "owner_dead"
+unique_lock ul(&mutex);
+//mutex left locked if "owner_dead" is thrown
+
          
+
+
          
+Throwing an exception with owner_dead might be also undesirable if
+robust-mutex support is added to C++ and the user has the equivalent of
+pthread_mutex_consistent() to notify the user has fixed the corrupted
+data and the mutex state should be marked consistent.
 
          
 
+
            
+
          1. 
+For state_not_recoverable add it to the list of Error conditions:
+
            2. 
+
          2. 
+For owner_dead, no proposed resolution.
+
            3. 
+
          
+
 
          [
 Summit:
 ]
          
 
 
 
          
-Agree with issue and change to 23.2.3 [sequence.reqmts]. The
-changes required to 21 [strings] will be part of the general
-concept support for that clause.
+Not a defect. Handling these error conditions is an implementation
+detail and must be handled below the C++ interface.
 
          
 
 
 
 
          Proposed resolution:
          
+
 
          
-Strike 23.2.3 [sequence.reqmts]p9-11. Make sure std::basic_string
-has constraints similar to
-std::vector to meet this old guarantee. 
+Add to 30.4.1 [thread.mutex.requirements], p12:
+
          
+
+
          
+
          
+-12- Error conditions:
 
          
 
+
            
+
          • 
+operation_not_permitted -- if the thread does not have the necessary permission to change 
+the state of the mutex.
+
            • 
+
          • 
+resource_deadlock_would_occur -- if the current thread already owns the mutex and is able 
+to detect it.
+
            • 
+
          • 
+device_or_resource_busy --  if the mutex is already locked and blocking is not possible.
+
            • 
+
          • 
+state_not_recoverable -- if the state protected by the mutex is not recoverable.
+
            • 
+
          
+
          
+
 
 
 
 
 
          
-
          1057. RandomNumberEngineAdaptor
          
-
          Section: 26.5 [rand] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-15
          
-
          View all other issues in [rand].
          
-
          View all issues with NAD Concepts status.
          
+
          988. Reflexivity meaningless?
          
+
          Section: X [concept.comparison] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-02-24  Last modified: 2009-07-16
          
+
          View all other issues in [concept.comparison].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
-
-
          
-The RandomNumberEngineAdaptor concept breaks precedent in the
-way the library has been specified by grouping requirements into a
-concept that is never actually used in the library.
-
          
 
          
-This is undoubtedly a very helpful device for documentation, but we are not
-comfortable with the precedent - especially as we have rejected national
-body comments on the same grounds.
+X [concept.comparison] p2:
 
          
 
          
-Suggest either removing the concept, or providing an algorithm/type that
-requires this concept in their definition (such as a factory function to
-create new engines).
+Due to the subtle meaning of == inside axioms, the Reflexivity axiom does
+not do anything as written. It merely states that a value is substitutable
+with itself, rather than asserting a property of the == operator.
 
          
+
+
+Original proposed resolution:
+
+
 
          
-The preference is to create a single new algorithm and retain the value of
-the existing documentation.
+Change the definition of Reflexivity in X [concept.comparison]:
 
          
 
+
          axiom Reflexivity(T a) { (a == a) == true; }
+
          
+
 
          [
-Batavia (2009-05):
+Post Summit:
 ]
          
 
+
 
          
 
          
-Walter points out that it is unlikely that any algorithm would ever
-require this concept, but that the concept nonetheless is useful as
-documentation, and (via concept maps) as a means of checking specific adapters.
-
          
-
          
-Alisdair disagrees as to the concept's value as documentation.
-
          
-
          
-Marc points out that the RandomNumberDistribution
-is also a concept not used elsewhere in the Standard.
-
          
-
          
-Pete agrees that a policy of not inventing concepts
-that aren't used in the Standard is a good starting point,
-but should not be used as a criterion for rejecting a concept.
+Alisdair: I was wrong.
 
          
 
          
-Move to Open.
+Recommend NAD.
 
          
 
          
 
 
+
 
          Proposed resolution:
          
+
          
+NAD.
+
          
 
 
 
 
 
 
          
-
          1058. New container issue
          
-
          Section: 23.2.3 [sequence.reqmts] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-13
          
-
          View all other issues in [sequence.reqmts].
          
-
          View all issues with NAD Editorial status.
          
+
          989. late_check and library
          
+
          Section: 17 [library] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-02-24  Last modified: 2009-07-16
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
+
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-
 
          
-Sequence containers 23.2.3 [sequence.reqmts]:
+The example in 6.9p2 shows how late_check blocks inhibit concept_map lookup
+inside a constrained context, and so inhibit concept map adaption by users
+to meet template requirements.
 
          
-
 
          
-The return value of new calls added to table 83 are not specified.
+Do we need some text in clause 17 prohibitting use of late_check in library
+template definitions unless otherwise documented?
 
          
 
 
          [
-Batavia (2009-05):
+Doug adds:
 ]
          
 
+
 
          
-
          
-We agree with the proposed resolution.
-
          
-
          
-Move to NAD Editorial.
-
          
+We need something like this, but it should be a more general statement
+about implementations respecting the concept maps provided by the
+user. Use of late_check is one way in which implementations can
+subvert the concept maps provided by the user, but there are other
+ways as well ("pattern-based" overloading, tricks with "auto" concept
+maps and defaulted associated type arguments).
 
          
 
-
-
          Proposed resolution:
          
-
          
-Add after p6 23.2.3 [sequence.reqmts]:
-
          
+
          [
+Batavia (2009-05):
+]
          
 
 
          
-
          
--6- ...
-
          
-
          
-The iterator returned from a.insert(p,rv) points to the copy of rv
-inserted into a.
-
          
-
          
-The iterator returned from a.emplace(p, args) points to the new
-element constructed from args inserted into a.
-
          
+Move to Open, pending proposed wording from Alisdair and/or Doug for further review.
 
          
 
 
+
          Proposed resolution:
          
+
+
 
 
 
 
          
-
          1059. Usage of no longer existing FunctionType concept
          
-
          Section: 20.7.16.2 [func.wrap.func] Status: NAD Concepts
- Submitter: Daniel Krügler Opened: 2009-03-13  Last modified: 2009-07-16
          
-
          View all other issues in [func.wrap.func].
          
-
          View all issues with NAD Concepts status.
          
+
          992. Response to UK 169
          
+
          Section: 17.6.1.1 [contents] Status: NAD
+ Submitter: P.J. Plauger Opened: 2009-03-03  Last modified: 2009-07-22
          
+
          View all other issues in [contents].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
+
          Addresses UK 169
          
 
          
-Due to a deliberate core language decision, the earlier called
-"foundation" concept std::FunctionType had been removed in
-N2773
-shortly
-before the first "conceptualized" version of the WP
-(N2798)
-had been
-prepared. This caused a break of the library, which already used this
-concept in the adapted definition of std::function
-(20.7 [function.objects]/2, header <functional> synopsis and
-20.7.16.2 [func.wrap.func]).
-
          
-
          
-A simple fix would be to either (a) make std::function's primary template
-unconstrained or to (b) add constraints based on existing (support) concepts.
-A more advanced fix would (c) introduce a new library concept.
-
          
-
          
-The big disadvantage of (a) is, that users can define templates which
-cause compiler errors during instantiation time because of under-constrainedness
-and would thus violate the basic advantage of constrained
-code.
-
          
-
          
-For (b), the ideal constraints for std::function's template parameter would
-be one which excludes everything else but the single provided partial
-specialization that matches every "free function" type (i.e. any function
-type w/o cv-qualifier-seq and w/o ref-qualifier).
-Expressing such a type as as single requirement would be written as
-
          
-
          template<typename T>
-requires ReferentType<T> // Eliminate cv void and function types with cv-qual-seq
-                         //   or ref-qual (depending on core issue #749)
-      && PointeeType<T>  // Eliminate reference types
-      && !ObjectType<T>  // Eliminate object types
-
          
-
          
-Just for completeness approach (c), which would make sense, if the
-library has more reasons to constrain for free function types:
-
          
-
          auto concept FreeFunctionType<typename T>
-  : ReferentType<T>, PointeeType<T>, MemberPointeeType<T>
-{
-  requires !ObjectType<T>;
-}
-
          
-
          
-I mention that approach because I expect that free function types belong
-to the most natural type categories for every days coders. Potential
-candidates in the library are addressof and class template packaged_task.
+This phrasing contradicts later freedom to implement the C standard
+library portions in the global namespace as well as std. (17.6.2.3p4)
 
          
 
 
          [
 Batavia (2009-05):
 ]
          
 
+
          
+The proposed wording seems to go too far.
+Move back to Open.
+
          
+
+
          [
+2009-07 Frankfurt:
+]
          
+
+
 
          
 
          
-Alisdair would prefer to have a core-supported FunctionType concept
-in order that any future changes be automatically correct
-without need for a library solution to catch up;
-he points to type traits as a precedent.
-Further, he believes that a published concept can't in the future
-be changed.
+Howard to add NB reference to the description of this issue.
 
          
 
          
-Bill feels this category of entity would change sufficiently slowly
-that he would be willing to take the risk.
+Move to NAD. This comment is informative and not normative by the use of
+the word "are" instead of the word "shall."
 
          
 
          
-Of the discussed solutions, we tend toward option (c).
-We like the idea of having a complete taxonomy of native types,
-and perhaps erred in trimming the set.
+A note linking to Annex D would help clarify the intention, here.
 
          
 
          
-We would like to have this issue reviewed by Core and would like
-their feedback.  Move to Open.
+Robert to Open a separate issue proposing that the standard C headers be
+undeprecated, for the purpose of clarifying the standard.
 
          
 
          
 
-
-
          Proposed resolution:
          
-
            
-
          1. 
-
            
-Change in 20.7 [function.objects]/2, Header <functional> synopsis:
-
            
-
            // 20.6.16 polymorphic function wrappers:
-class bad_function_call;
-template<FunctionTypeReferentType F>
-requires PointeeType<F> && !ObjectType<F>
-class function; // undefined
-
            
-
            2. 
-
          2. 
-
            
-Change in 20.7.16.2 [func.wrap.func]:
-
            
-
            namespace std {
-template<FunctionTypeReferentType F>
-requires PointeeType<F> && !ObjectType<F>
-class function; // undefined
-
            
-
            3. 
-
          
-
-
+
          [
+2009-07-22 Bill modified the proposed wording with a clarifying footnote.
+]
          
 
 
 
-
          
-
          1060. Embedded nulls in NTBS
          
-
          Section: 17.5.2.1.4.1 [byte.strings] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-03-13  Last modified: 2009-07-13
          
-
          View all issues with NAD Editorial status.
          
-
          Discussion:
          
 
+
          Proposed resolution:
          
 
          
-Definition of null-terminated sequences allow for embedded nulls. This is
-surprising, and probably not supportable with the intended use cases.
+Add a footnote to 17.6.1.1 [contents], p2:
 
          
 
-
          [
-Batavia (2009-05):
-]
          
-
 
          
-We agree with the issue, but believe this can be handled editorially.
-Move to NAD Editorial.
-
          
-
+
          
+-2- All library entities except macros, operator new and operator
+delete are defined within the namespace std or namespaces
+nested within namespace std*.
+
          
 
+
          
+*The C standard library headers D.6 [depr.c.headers] also define
+names within the global namespace, while the C++ headers for
+C library facilities 17.6.1.2 [headers] may also define names within
+the global namespace.
+
          
+
          
 
-
          Proposed resolution:
          
 
 
 
 
 
 
          
-
          1061. Bad indexing for tuple access to pair (Editorial?)
          
-
          Section: 20.3.4 [pair.astuple] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-03-13  Last modified: 2009-07-13
          
-
          View all issues with NAD Editorial status.
          
+
          995. Operational Semantics Unclear
          
+
          Section: 17.5.1.3 [structure.requirements] Status: NAD
+ Submitter: David Abrahams Opened: 2009-03-06  Last modified: 2009-07-13
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
-
 
          
-The definition of get implies that get must return the second element if
-given a negative integer.
+As a practical matter there's disagreement on the meaning of operational
+semantics.  If the text in 17.5.1.3 [structure.requirements]p4 isn't
+clear, it should be clarified.  However, it's not clear whether the
+disagreement is merely due to people not being aware of the text.
 
          
 
 
          [
@@ -26028,866 +30128,811 @@ Batavia (2009-05):
 ]
          
 
 
          
-Move to NAD Editorial.
+Agree with the recommended NAD resolution.
 
          
 
 
-
 
          Proposed resolution:
          
 
          
-20.3.4 [pair.astuple] p5:
+Recommend NAD.  The text in 17.5.1.3 [structure.requirements] is
+perfectly clear.
 
          
 
-
          template<int size_t I, class T1, class T2> 
-  requires True<(I < 2)> 
-  const P& get(const pair<T1, T2>&);
-
          
-
          
-
-
 
 
 
 
 
          
-
          1063. 03 iterator compatibilty
          
-
          Section: D.10.4 [iterator.backward] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-15  Last modified: 2009-07-16
          
+
          1000. adjacent_find is over-constrained
          
+
          Section: 25.2.8 [alg.adjacent.find] Status: NAD Concepts
+ Submitter: Chris Jefferson Opened: 2009-03-09  Last modified: 2009-07-15
          
+
          View all other issues in [alg.adjacent.find].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-
 
          
-Which header must a user #include to obtain the library-supplied
-concept_maps declared in this paragraph?
+Addresses UK 296
 
          
 
 
          
-This is important information, as existing user code will break if this
-header is not included, and we should make a point of mandating this header
-is #include-d by library headers likely to make use of it, notably
-<algorithm>.  See issue 1001 for more details.
+adjacent_find in C++03 allows an arbitrary predicate, but in C++0x
+EqualityComparable/EquivalenceRelation is required. This forbids a
+number of use cases, including:
 
          
-
-
          [
-Batavia (2009-05):
-]
          
-
 
          
-We agree with the direction of the proposed resolution.
-Move to Tentatively Ready.
-
          
-
-
          [
-2009-07 Frankfurt
-]
          
+
+
+
+
+
+
+
+
+
+
          
+adjacent_find(begin, end, less<double>)
+
+Find the first
+place where a range is not ordered in decreasing order - in use to check
+for sorted ranges.
+
          
+adjacent_find(begin, end, DistanceBiggerThan(6) ) )
+
+Find the first
+place in a range where values differ by more than a given value - in use
+to check an algorithm which produces points in space does not generate
+points too far apart.
+
          
+
          
 
+
          
+A number of books use predicate which are not equivalence relations in
+examples, including "Thinking in C++" and "C++ Primer".
+
          
+
+
          
+Adding the requirement that the predicate is an EquivalenceRelation
+does not appear to open up any possibility for a more optimised algorithm.
+
          
 
-
          
-We believe this is NAD Concepts, but this needs to be reviewed against the
-post-remove-concepts draft.
-
          
 
 
 
          Proposed resolution:
          
-
          Change D.10 [depr.lib.iterator.primitives], Iterator primitives, as
-indicated:
          
+
          
+Change the definition of adjacent_find in the synopsis of 25 [algorithms]
+and 25.2.8 [alg.adjacent.find] to:
+
          
 
-
          
-  
          To simplify the use of iterators and provide backward compatibility with
-  previous C++ Standard Libraries,
-  the library provides several classes and functions. Unless otherwise
-  specified, these classes and functions shall be defined in header <iterator>.
          
-
          
-
          Change D.10.4 [iterator.backward], Iterator backward compatibility, as
-indicated:
          
-
          
-  
          The library provides concept maps that allow iterators specified with
-  iterator_traits to interoperate with
-  algorithms that require iterator concepts. These concept maps shall be
-  defined in the same header that defines the iterator. [Example:
          
-
          
+
          template<ForwardIterator Iter> 
+  requires EqualityComparableHasEqualTo<Iter::value_type, Iter::value_type>
+  Iter adjacent_find(Iter first, Iter last);
+
+template<ForwardIterator Iter, EquivalenceRelationPredicate<auto, Iter::value_type, Iter::value_type> Pred> 
+  requires CopyConstructible<Pred> 
+  Iter adjacent_find(Iter first, Iter last, Pred pred);
+
          
 
 
 
 
 
 
          
-
          1067. simplified wording for inner_product
          
-
          Section: 26.7 [numeric.ops] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-17  Last modified: 2009-07-14
          
+
          1001. Pointers, concepts and headers
          
+
          Section: 17 [library] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-10  Last modified: 2009-07-18
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
 
+
          Addresses UK 78
          
+
 
          
-One of the motivating examples for introducing requirements-aliases was to
-simplify the wording of the inner_product requirements.  As the paper
-adopting the feature and constrained wording for the library went through in
-the same meeting, it was not possible to make the change at the time.  The
-simpler form should be adopted now though.  Similarly, most the other
-numerical algorithms can benefit from a minor cleanup.
+Related to 1063.
 
          
+
 
          
-Note that in each case, the second more generalised form of the algorithm
-does not benefit, as there are already named constraints supplied by the
-template type parameters.
+This is effectively an extension of LWG issue 343.
+
          
+
          
+We know there is an increasing trend (encouraged by conformance testers and
+some users) that each library header should supply no more than required to
+satisfy the synopsis in the standard.  This is typically achieved by
+breaking larger headers into smaller subsets, and judicious use of forward
+declarations.
+
          
+
          
+If we apply this policy to C++0x (per
+N2800)
+it will be very surprising for
+people using library algorithms over ranges defined by pointers that they
+must #include <iterator_concepts> for their code to compile again.  That is
+because pointers do not satisfy any of the iterator concepts without the
+concept_map supplied in this header.
+
          
+
          
+Therefore, I suggest we should require all library headers that make use of
+iterator concepts are specifically required to #include <iterator_concepts>.
+
          
+
          
+At a minimum, the list of headers would be: (assuming all are constrained by
+concepts)
 
          
+
          algorithm
+array
+deque
+forward_list
+initializer_list
+iterator
+locale
+list
+map
+memory          // if 1029 is adopted
+memory_concepts
+numeric
+random
+regex
+set
+string
+tuple
+unordered_map
+unordered_set
+utility
+vector
+
          
 
 
          [
-2009-05-02 Daniel adds:
+Ganesh adds:
 ]
          
 
 
 
          
 
          
-one part of the suggested resolution suggests the removal of the
-MoveConstructible<T> requirement from
-inner_product. According to 26.7.2 [inner.product]
+The same problems exists for <memory_concepts> and
+<container_concepts>.
 
          
-
-
          
-Computes its result by initializing the accumulator acc with the
-initial value init
-
          
-
 
          
-this step requires at least MoveConstructible.
+In order to compile <vector> you just need the
+definitions of the concepts in <memory_concepts>, the
+concept maps defined there are not necessary. Yet, from the user point
+of view, if the concept map template for AllocatableElement are
+not in scope, <vector> is pretty useless. Same for
+<tuple> and ConstructibleWithAllocator.
 
          
-
 
          
-Therefore I strongly suggest to take this removal back (Note also
-that the corresponding overload with a functor argument still has
-the same MoveConstructible<T> requirement).
+Similarly, <queue> is not very useful if the concept map
+template for QueueLikeContainer is not in scope, although the
+definition of concept alone is theoretically sufficient.
+
          
+
          
+There's a pattern here: if a concept has concept maps "attached", they
+should never be separated.
 
          
 
          
 
 
          [
-Batavia (2009-05):
+Beman provided the proposed resolution for the May 2009 mailing. He 
+comments:
 ]
          
 
+
 
          
-
          
-We agree with the proposed resolution as amended by Daniel's suggestion
-to restore MoveConstructible,
-reflected in the updated proposed resolution below.
-
          
-
          
-Move to Tentatively Ready.
-
          
+
+
          Initially I tried to specify exactly what header should include what other 
+headers. This was verbose, error prone, hard to maintain, and appeared to add 
+little value compared to just stating the general rule.
          
+
 
          
 
+
          [
+Batavia (2009-05):
+]
          
 
-
          Proposed resolution:
          
+
          
 
          
-Change in 26.7 [numeric.ops] and  [accumulate]:
+Pete believes the proposed wording overconstrains implementers.
+Instead of specifying the mechanism,
+he prefers a solution that spells out what needs to be declared,
+rather than how those declarations are to be provided,
+e.g.,
 
          
-
-
          template <InputIterator Iter, MoveConstructible T>
- requires add = HasPlus<T, Iter::reference>
-       && HasAssign<T, HasPlus<T, Iter::reference> add::result_type>
- T accumulate(Iter first, Iter last, T init);
-
          
-
+
          
+A C++ header shall provide the names
+that are required to be defined in that header.
+
          
 
          
-Change in 26.7 [numeric.ops] and 26.7.2 [inner.product]:
+Bill suggests approaching the wording from a programmer's perspective.
+We may want to consider promising that certain widely-used headers
+(e.g., the concept headers) are included when needed by other headers.
+He feels, however, there is nothing broken now,
+although we may want to consider "something nicer."
 
          
-
-
          template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T>
-  requires mult = HasMultiply<Iter1::reference, Iter2::reference>
-        && add = HasPlus<T, HasMultiply<Iter1::reference, Iter2::reference> mult::result_type>
-        && HasAssign< 
-             T,
-             HasPlus<T,
-                     HasMultiply<Iter1::reference, Iter2::reference>::result_type> add::result_type>
-  T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);
-
          
-
 
          
-Change in 26.7 [numeric.ops] and 26.7.3 [partial.sum]:
+Move to Open status.
 
          
 
-
          template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
-  requires add = HasPlus<InIter::value_type, InIter::reference>
-        && HasAssign<InIter::value_type,
-                     HasPlus<InIter::value_type, InIter::reference> add::result_type>
-        && Constructible<InIter::value_type, InIter::reference>
-  OutIter partial_sum(InIter first, InIter last, OutIter result);
-
          
+
          
 
-
          
-Change in 26.7 [numeric.ops] and 26.7.4 [adjacent.difference]:
-
          
+
          [
+2009-06-16 Beman updated the proposed resolution:
+]
          
 
-
          template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
-  requires sub = HasMinus<InIter::value_type, InIter::value_type>
-        && Constructible<InIter::value_type, InIter::reference>
-        && OutputIterator<OutIter, HasMinus<InIter::value_type, InIter::value_type> sub::result_type>
-        && MoveAssignable<InIter::value_type>
-  OutIter adjacent_difference(InIter first, InIter last, OutIter result);
-
          
 
+
          
+  
            
+    
          • The mechanism is no longer specified, as requested in Batavia.
            • 
+    
          • The footnote has been removed since it specified mechanism and also did 
+    not reflect existing practice.
            • 
+    
          • A sentence was added that makes it clear that the existing practice is 
+    permitted.
            • 
+  
          
+
          
 
+
          [
+2009-07-15 Beman updated the proposed resolution:
+]
          
 
 
+
          [
+2009-07-17 Beman updated the proposed resolution based on feedback from the LWG in Frankfurt:
+]
          
 
 
-
          
-
          1072. Is std::hash a constrained template or not?
          
-
          Section: 20.7.17 [unord.hash] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-19  Last modified: 2009-07-16
          
-
          View other active issues in [unord.hash].
          
-
          View all other issues in [unord.hash].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
          
+
            
+
          • Strike two pieces of text considered unnecessary.
            • 
+
          • Change "definitions" to "declarations and definitions" in two places.
            • 
+
          • Wording tightened slightly.
            • 
+
          
+
          
 
-
          
-Is std::hash a constrained template or not?
-
          
-
          
-According to Class template hash 20.7.17 [unord.hash], the definition is:
-
          
+
          [
+2009-07 Frankfurt:
+]
          
 
-
          template <class T>
-struct hash : public std::unary_function<T, std::size_t> {
-  std::size_t operator()(T val) const;
-};
-
          
 
+
          
 
          
-And so unconstrained.
+Revised Proposed Resolution:
 
          
 
          
-According to the <functional> synopsis in p2 Function objects
-20.7 [function.objects] the template is declared as:
+A C++ header may include other C++ headers. A C++ header shall provide
+the declarations and definitions that appear in its synopsis (3.2
+[basic.def.odr]). A C++ header shown in its synopsis as including other
+C++ headers shall provide the declarations and definitions that appear
+in the synopses of those other headers.
 
          
-
-
          template <ReferentType T> struct hash;
-
          
-
 
          
-which would make hash a constrained template.
+Alisdair: Does this address the BSI comment?
 
          
-
-
          [
-2009-03-22 Daniel provided wording.
-]
          
-
-
-
          [
-Batavia (2009-05):
-]
          
-
-
          
 
          
-Alisdair is not certain that Daniel's proposed resolution is sufficient,
-and recommends we leave the hash template unconstrained for now.
+Beman: There were several overlapping comments. I tried to handle them
+all with one resolution.
 
          
 
          
-Recommend that the Project Editor make the constrained declaration consistent
-with the definition in order to make the Working Paper internally consistent,
-and that the issue then be revisited.
+Alisdair: I'd prefer to see this closed as NAD and have this resolution
+be the subject of some other, new issue.
 
          
 
          
-Move to Open.
+Move to NAD Concepts. Howard to open a new issue (1178) in Ready state with the
+Proposed Resolution above. Beman will write up a discussion for the new
+issue.
 
          
 
          
 
 
-
          Proposed resolution:
          
 
-
          
-[To the editor: This resolution is merge-compatible to the
-resolution of 1078]
-
          
+
          Proposed resolution:
          
+
          Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:
          
 
-
            
-
          1. 
-
            
-In 20.7 [function.objects]/2, header <functional> synopsis, change as indicated:
-
            
+
            
 
-
            // 20.6.17, hash function base template:
-template <ReferentType T> struct hash; // undefined
-
            
-
            2. 
-
          2. 
-
            
-In 20.7.17 [unord.hash]/1 change as indicated:
-
            
-
            namespace std {
- template <class T>
- struct hash : public std::unary_function<T, std::size_t> {
- std::size_t operator()(T val) const;
- };
- template <ReferentType T> struct hash; // undefined
-}
-
            
-
            3. 
-
          3. 
 
            
-In 20.7.17 [unord.hash]/2 change as indicated:
+A C++ header may include other C++
+headers.[footnote] A C++ header shall provide
+the declarations and definitions that appear in its synopsis
+(3.2 [basic.def.odr]). A C++ header shown in its synopsis as including 
+other C++ headers shall provide the same declarations and definitions as
+if those other headers were included.
 
            
 
-
            
--2-  For all library-provided specializations, the template
-instantiation hash<T>
-  shall provide a public operator() with return type std::size_t to
-satisfy the concept
-  requirement Callable<const hash<T>, const T&>. If T is an object
-type or reference to
-  object, hash<T> shall be publicly derived from
-std::unary_function<T, std::size_t>.
-   The return value of operator() is unspecified, except that
-equal arguments
-  shall yield the same result. operator() shall not throw exceptions.
+  
            [footnote] C++ headers must include a C++ header that contains 
+  any needed definition (3.2).
            
 
            
-
            4. 
-
          4. 
-
            
-In 18.7 [support.rtti]/1, header <typeinfo> synopsis change as indicated:
-
            
-
            namespace std {
-  class type_info;
-  class type_index;
-  template <classReferentType T> struct hash;
-
            
-
            5. 
-
          
+
 
 
 
 
 
 
          
-
          1074. concept map broken by N2840
          
-
          Section: 20.8.3 [allocator.element.concepts] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-03-19  Last modified: 2009-07-13
          
-
          View all issues with NAD Concepts status.
          
+
          1002. Response to UK 170
          
+
          Section: 17.6.1.2 [headers] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all other issues in [headers].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
 
-
          
-p7 Allocator-related element concepts 20.8.3 [allocator.element.concepts]
-
          
+
          Addresses UK 170
          
 
 
          
-The changes to the AllocatableElement concept mean this concept_map
-specialization no longer matches the original concept:
+One of goals of C++0x is to make language easier to teach and for
+'incidental' programmers. The fine-grained headers of the C++ library
+are valuable in large scale systems for managing dependencies and
+optimising build times, but overcomplicated for simple development and
+tutorials. Add additional headers to support the whole library through a
+single include statement.
 
          
 
-
          template <Allocator Alloc, class T, class ... Args>
-  requires HasConstructor<T, Args...>
-    concept_map AllocatableElement<Alloc, T, Args&&...> {
-      void construct_element(Alloc& a, T* t, Args&&... args) {
-        Alloc::rebind<T>(a).construct(t, forward(args)...);
-      }
-    }
-
          
-
 
          [
-2009-03-23 Pablo adds:
+Batavia (2009-05):
 ]
          
 
-
 
          
-Actually, this is incorrect,
-N2840
-says. "In section 
-20.8.3 [allocator.element.concepts] paragraph 8, modify the definition of the
-AllocatableElement concept and eliminate the related concept map:" but
-then neglects to include the red-lined text of the concept map that was
-to be eliminated. Pete also missed this, but I caught it he asked me to
-review his edits.  Pete's updated WP removes the concept map entirely,
-which was the original intent.  The issue is, therefore, moot.  Note, as
-per my presentation of
-N2840
-in summit, construct() no longer has a
-default implementation.  This regrettable fact was deemed (by David
-Abrahams, Doug, and myself) to be preferable to the complexity of
-providing a default implementation that would not under-constrain a more
-restrictive allocator (like the scoped allocators).
+We do not all agree that this is an issue,
+but we agree that if it needs solving this is the right way to do it.
+Move to Tentatively Ready.
 
          
 
 
          [
-2009-05-01 Daniel adds:
+2009-07-06 Beman notes:
 ]
          
 
+
 
          
 
          
-it seems to me that #1074 should be resolved as a NAD, because the
-current WP has already removed the previous AllocatableElement concept map.
-It introduced auto concept AllocatableElement instead, but as of
-20.8.3 [allocator.element.concepts]/7 this guy contains now
+This issue
+adds a header <std>.
+
          
+
          
+There is a paper to be looked at,
+N2905
+Aggregation headers, that adds
+a header <std-all> that is the same thing except it excludes
+deprecated headers.
+N2905
+also proposes a second aggregation header.
+
          
+
          
+Seems like this issue should be held in abeyance until the LWG has had
+a chance to look at N2905.
 
          
-
          requires FreeStoreAllocatable<T>;
-void Alloc::construct(T*, Args&&...);
-
          
 
          
 
 
          [
-Batavia (2009-05):
+2009-07-06 Howard:  I've pulled this issue back to Review.
+]
          
+
+
+
          [
+2009-07 Frankfurt
 ]
          
 
+
 
          
-
          
-The affected code is no longer part of the Working Draft.
-
          
-
          
-Move to NAD.
-
          
+No consensus for change.
 
          
 
 
+
 
          Proposed resolution:
          
 
          
-Change 20.8.3 [allocator.element.concepts]:
+Insert a new paragraph in 17.6.1.2 [headers] between p4 and p5
 
          
-
-
          template <Allocator Alloc, class T, class ... Args>
-  requires HasConstructor<T, Args...>
-    concept_map AllocatableElement<Alloc, T, Args&&...> {
-      void construct_element(Alloc& a, T* t, Args&&... args) {
-        Alloc::rebind<T>(a).construct(t, forward(args)...);
-      }
-    }
-
          
-
+
          
+An additional header <std> shall have the effect of
+supplying the entire standard library.  [Note: for example, it
+might be implemented as a file with an #include statement for each of the
+headers listed in tables 13 and 14. -- end note]
+
          
 
 
 
 
 
 
          
-
          1077. Nonesense tuple declarations
          
-
          Section: 20.5.2 [tuple.tuple] Status: NAD Editorial
- Submitter: Pete Becker Opened: 2009-03-20  Last modified: 2009-07-13
          
-
          View all other issues in [tuple.tuple].
          
-
          View all issues with NAD Editorial status.
          
+
          1003. Response to JP 23
          
+
          Section: 17.6.1.3 [compliance] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
          
+
          View all other issues in [compliance].
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
-
          
-Class template tuple 20.5.2 [tuple.tuple]:
-
          
 
-
          template <class... UTypes>
-  requires Constructible<Types, const UTypes&>...
-template <class... UTypes>
-  requires Constructible<Types, RvalueOf<UTypes>::type>...
-
          
+
          Addresses JP 23
          
 
 
          
-Somebody needs to look at this and say what it should be.
-
          
+There is a freestanding implementation including
+<type_traits>, <array>,
+<ratio>, lately added to Table 13, C++ library headers.
+Programmers think them useful and hope that these headers are also added
+to Table 15, C++ headers for freestanding implementations, that shows
+the set of headers which a freestanding implementation shall include at
+least.
+
          
+
+
          Original proposed resolution
          
+
+
          
+Add <type_traits>, <array>,
+<ratio> to Table 15.
+
          
 
 
          [
-2009-03-21 Daniel provided wording.
+Summit:
 ]
          
 
 
+
          
+
          
+ The <array> header has far too many dependencies to require for a
+free-standing implementation.
+
          
+
          
+The <ratio> header would be useful, has no dependencies, but is not
+strictly necessary.
+
          
+
          
+The <type_traits> header is fundamentally a core language facility with a
+library interface, so should be supported.
+
          
+
+
          
+(it is anticipated the resolution will come via an update to paper
+N2814)
+(see also LWG 833)
+
          
+
          
+
 
          [
 Batavia (2009-05):
 ]
          
 
 
          
-The resolution looks correct; move to NAD Editorial.
+Leave in Review status pending a paper on freestanding implementations
+by Martin Tasker.
 
          
 
+
          [
+2009-07 Frankfurt:
+]
          
+
 
-
          Proposed resolution:
          
+
          
 
          
-In 20.5.2 [tuple.tuple], class tuple, change as indicated:
+Move this to NAD.
+
          
+
          
+We considered all of the listed headers, and found a compelling case
+only for the inclusion of <type_traits> in the list of headers required
+of a freestanding implementation.
+
          
+
          
+See Martin Tasker's paper 
+Fixing Freestanding
+which provides the wording to include <type_traits> into freestanding
+implementations.
 
          
+
          
 
-
          template <class... UTypes>
-  requires Constructible<Types, const UTypes&>...
-  tuple(const pair<UTypes...>&);
-template <class... UTypes>
-  requires Constructible<Types, RvalueOf<UTypes>::type>...
-  tuple(pair<UTypes...>&&);
-
          
 
+
+
          Proposed resolution:
          
 
          
-[NB.: The corresponding prototypes do already exist in 20.5.2.1 [tuple.cnstr]/7+8]
+Add <type_traits> to Table 15.
 
          
 
 
 
 
 
+
 
          
-
          1078. DE-17: Remove class type_index
          
-
          Section: 18.7.2 [type.index] Status: NAD Concepts
- Submitter: Doug Gregor Opened: 2009-03-20  Last modified: 2009-07-16
          
+
          1005. numeric_limits partial specializations not concept enabled
          
+
          Section: 18.3.1.1 [numeric.limits] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
 
-
          Addresses DE 17
          
+
          Addresses JP 26
          
 
 
          
-DE-17: 
-
          
-
          
-The class type_index should be removed; it provides no additional
-functionality beyond providing appropriate concept maps.
+numeric_limits [partial specializations] does not use concept.
 
          
 
 
          [
-2009-03-31 Peter adds:
+Summit:
 ]
          
 
 
 
          
-
          
-It is not true, in principle, that std::type_index provides no  utility
-compared to bare std::type_info*.
-
          
-
          
-std::type_index can avoid the lifetime issues with type_info when  the
-DLL that has produced the type_info object is unloaded. A raw
-type_info* does not, and cannot, provide any protection in this  case.
-A type_index can (if the implementor so chooses) because it  can wrap a
-smart (counted or even cloning) pointer to the type_info  data that is
-needed for name() and before() to work.
-
          
+Alisdair will provide a soltion as part of treatment of axioms and LWG 902.
 
          
 
+
          [
+Post Summit:
+]
          
 
 
-
          Proposed resolution:
          
-
          Modify the header <typeinfo> synopsis in 
-  18.7 [support.rtti]p1 as follows:
          
+
          
+Alisdair recommends NAD as the partial specializations are already
+constrained by requirements on the primary template.
+
          
 
-
          namespace std { 
-  class type_info; 
-  class type_index;
-  template <class T> struct hash;
-  template<> struct hash<type_indexconst type_info *> : public std::unary_function<type_indexconst type_info *, size_t> {
-    size_t operator()(type_indexconst type_info * indext) const;
-  };
-  concept_map LessThanComparable<const type_info *> see below
-  class bad_cast; 
-  class bad_typeid;
-}
-
          
+
          [
+Batavia (2009-05):
+]
          
 
-
          Add the following new subsection
          
 
          
-
          
-18.7.1.1 Template specialization hash<const type_info *>
-[type.info.hash]
          
-
-
          size_t operator()(const type_info *x) const;
-
          
-
            
-
          1. Returns: x->hash_code()
            2. 
-
          
+The Working Draft does not in general repeat a primary template's constraints
+in any specializations.
+Move to NAD.
 
          
 
- 
          Add the following new subsection
          
- 
          
-
          18.7.1.2 type_info concept map [type.info.concepts]
          
+
          [
+2009-05-25 Howard adds:
+]
          
 
 
-
          concept_map LessThanComparable<const type_info *> {
-  bool operator<(const type_info *x, const type_info *y) { return x->before(*y); }
-  bool operator<=(const type_info *x, const type_info *y) { return !y->before(*x); }
-  bool operator>(const type_info *x, const type_info *y) { return y->before(*x); }
-  bool operator>=(const type_info *x, const type_info *y) { return !x->before(*y); }
-}
-
          
-
            
-  
          1. Note: provides a well-defined ordering among
-  type_info const pointers, which makes such pointers
-  usable in associative containers (23.4).
            2. 
-
          
+
          
+A c++std-lib thread starting at c++std-lib-23880 has cast doubt that NAD is the
+correct resolution of this issue.  Indeed the discussion also casts doubt that
+the current proposed wording is the correct resolution as well.  Personally I'm
+inclined to reset the status to Open.  However I'm reverting the status to 
+that which it had prior to the Batavia recommendation.  I'm setting back to Review.
 
          
 
-
          Remove section 18.7.2 [type.index]
          
+
+
          Proposed resolution:
          
+
          
+Change 18.3.1.1 [numeric.limits]:
+
          
+
+
          template<class Regular T> class numeric_limits<const T>;
+template<class Regular T> class numeric_limits<volatile T>;
+template<class Regular T> class numeric_limits<const volatile T>;
+
          
+
 
 
 
 
 
 
          
-
          1080. Concept ArithmeticLike should provide explicit boolean  conversion
          
-
          Section: 20.2.13 [concept.arithmetic] Status: NAD Concepts
- Submitter: Daniel Krügler Opened: 2009-03-21  Last modified: 2009-07-15
          
+
          1007. throw_with_nested not concept enabled
          
+
          Section: 18.8.6 [except.nested] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View other active issues in [except.nested].
          
+
          View all other issues in [except.nested].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-
          
-Astonishingly, the current concept ArithmeticLike as specified in
-20.2.13 [concept.arithmetic] does not provide explicit conversion
-to bool although this is a common property of arithmetic types
-(4.12 [conv.bool]). Recent proposals that introduced such types
-(integers of arbitrary precision,
-n2143,
-decimals
-n2732
-indirectly
-via conversion to long long) also took care of such a feature.
-
          
-
          
-Adding such an explicit conversion associated function would also
-partly solve a currently invalid effects clause in library, which bases
-on this property, 24.2.6 [random.access.iterators]/2:
-
          
-
          { difference_type m = n;
- if (m >= 0) while (m--) ++r;
- else while (m++) --r;
- return r; }
-
          
-
-
          
-Both while-loops take advantage of a contextual conversion to bool
-(Another problem is that the >= comparison uses the no
-longer supported existing implicit conversion from int to IntegralLike).
-
          
 
-Original proposed resolution:
-
            
-
          1. 
-
            
-In 20.2.13 [concept.arithmetic], add to the list of less refined
-concepts one further concept:
-
            
+
            Addresses JP 29
            
 
-
            concept ArithmeticLike<typename T>
-  : Regular<T>, LessThanComparable<T>, HasUnaryPlus<T>, HasNegate<T>,
-    HasPlus<T, T>, HasMinus<T, T>, HasMultiply<T, T>, HasDivide<T, T>,
-    HasPreincrement<T>, HasPostincrement<T>, HasPredecrement<T>,
-    HasPostdecrement<T>,
-    HasPlusAssign<T, const T&>, HasMinusAssign<T, const T&>,
-    HasMultiplyAssign<T, const T&>,
-    HasDivideAssign<T, const T&>, ExplicitlyConvertible<T, bool> {
-
            
-
            2. 
-
          2. 
 
            
-In 24.2.6 [random.access.iterators]/2 change the current effects clause
-as indicated [The proposed insertion fixes the problem that the previous
-implicit construction from integrals has been changed to an explicit
-constructor]:
+throw_with_nested does not use concept.
 
            
-
            { difference_type m = n;
- if (m >= difference_type(0)) while (m--) ++r;
- else while (m++) --r;
- return r; }
-
            
-
            3. 
-
          
 
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+ 
 
          
-
          
-We agree that arithmetic types ought be convertible to bool,
-and we therefore agree with the proposed resolution's paragraph 1.
-
          
-
          
-We do not agree that the cited effects clause is invalid,
-as it expresses intent rather than specific code.
-
          
-
          
-Move to Review, pending input from concepts experts.
-
          
+Agreed.
 
          
 
 
 
 
          Proposed resolution:
          
+
 
          
-In 20.2.13 [concept.arithmetic], add to the list of less refined
-concepts one further concept:
+Alisdair initially proposed wording in
+N2619.
+
          
+
          
+We are awaiting an updated paper based on feedback from the San Francisco
+review.
 
          
-
-
          concept ArithmeticLike<typename T>
-  : Regular<T>, LessThanComparable<T>, HasUnaryPlus<T>, HasNegate<T>,
-    HasPlus<T, T>, HasMinus<T, T>, HasMultiply<T, T>, HasDivide<T, T>,
-    HasPreincrement<T>, HasPostincrement<T>, HasPredecrement<T>,
-    HasPostdecrement<T>,
-    HasPlusAssign<T, const T&>, HasMinusAssign<T, const T&>,
-    HasMultiplyAssign<T, const T&>,
-    HasDivideAssign<T, const T&>, ExplicitlyConvertible<T, bool> {
-
          
 
 
 
 
 
 
          
-
          1081. Response to UK 216
          
-
          Section: 21 [strings] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
-
          View all other issues in [strings].
          
-
          View all issues with NAD Concepts status.
          
+
          1009. InputIterator post-increment dangerous
          
+
          Section: X [iterator.iterators] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-22
          
+
          View all issues with NAD status.
          
 
          Discussion:
          
-
          Addresses UK 216, JP 46, JP 48
          
 
-
          
-All the containers use concepts for their iterator usage, exect for
-basic_string. This needs fixing.
-
          
+
          Addresses UK 251
          
 
 
          
-Use concepts for iterator template parameters throughout the chapter.
+The post-increment operator is dangerous for a general InputIterator.
+The multi-pass guarantees that make it meaningful are defined as part of
+the ForwardIterator refinement. Any change will affect only constrained
+templates that have not yet been written, so should not break existing
+user iterators which remain free to add these operations. This change
+will also affect the generalised OutputIterator, although there is no
+percieved need for the post-increment operator in this case either.
 
          
 
 
          [
-Summit:
+2009-07-28 Alisdair adds:
 ]
          
 
+
 
          
-NB comments to be handled by Dave Abrahams and Howard Hinnant with
-advice from PJP: UK216 (which duplicates) JP46, JP48. JP46 supplies
-extensive proposed wording; start there.
+We still think the issue is relevant, but needs totally rewording in
+non-concept language.  We would like to see the issue retained as Open,
+rather than deferred as NAD Concepts.  Review status is no longer
+appropriate.
 
          
 
-
-
          Proposed resolution:
          
-
+
          [
+2009-10 Santa Cruz:
+]
          
 
 
+
          
+NAD.  Without concepts we do not feel that input iterator post increment
+is broken.
+
          
 
 
-
          
-
          1082. Response to JP 49
          
-
          Section: 22 [localization] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
-
          View all other issues in [localization].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
-
          Addresses JP 49
          
 
+
          Proposed resolution:
          
 
          
-codecvt does not use concept. For example, create CodeConvert
-concept and change as follows.
+Change X [iterator.iterators]:
 
          
 
-
          template<CodeConvert Codecvt, class Elem = wchar_t>
-  class wstring_convert {
-
          
+
          concept Iterator<typename X> : Semiregular<X> { 
+  MoveConstructible reference = typename X::reference; 
+  MoveConstructible postincrement_result;
 
-
          [
-Summit:
-]
          
+  requires HasDereference<postincrement_result>;
+
+  reference operator*(X&&); 
+  X& operator++(X&); 
+  postincrement_result operator++(X&, int);
+}
+
          
+
+
          ...
          
+
          postincrement_result operator++(X& r, int);
+
          
 
 
          
-To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
+-3- Effects: equivalent to { X tmp = r; ++r; return tmp; }.
 
          
 
+
          
 
-
          Proposed resolution:
          
+
          
+Change 24.2.1 [input.iterators]:
+
          
 
+
          
+
          concept InputIterator<typename X> : Iterator<X>, EqualityComparable<X> { 
+  ObjectType value_type = typename X::value_type; 
+  MoveConstructible pointer = typename X::pointer; 
 
+  SignedIntegralLike difference_type = typename X::difference_type; 
 
+  requires IntegralType<difference_type> 
+        && Convertible<reference, const value_type &>; 
+        && Convertible<pointer, const value_type*>; 
 
+  requires Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
 
-
          
-
          1083. Response to JP 52, 53
          
-
          Section: 22 [localization] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
-
          View all other issues in [localization].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
-
          Addresses JP 52, JP 53
          
+  pointer operator->(const X&); 
+}
+
          
+
          
 
 
          
-InputIterator does not use concept.
+Change 24.2.2 [output.iterators]:
 
          
 
-
          
-OutputIterator does not use concept.
-
          
+
          
+
          auto concept OutputIterator<typename X, typename Value> { 
+  requires Iterator<X>; 
+
+  typename reference = Iterator<X>::reference; 
+  typename postincrement_result = Iterator<X>::postincrement_result;
+  requires SameType<reference, Iterator<X>::reference> 
+        && SameType<postincrement_result, Iterator<X>::postincrement_result>
+        && Convertible<postincrement_result, const X&>
+        && HasAssign<reference, Value> 
+        && HasAssign<HasDereference<postincrement_result>::result_type, Value>;
+}
+
          
+
          
 
 
          
-Comments include proposed wording.
+Change 24.2.3 [forward.iterators]:
 
          
 
 
          [
-Summit:
+See 1084 which is attempting to change this same area in a compatible
+way.
 ]
          
 
+
 
          
-To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
+
          concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> { 
+  requires Convertible<postincrement_result, const X&>;
+
+  MoveConstructible postincrement_result;
+  requires HasDereference<postincrement_result>
+        && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
+
+  postincrement_result operator++(X&, int);
+
+  axiom MultiPass(X a, X b) { 
+    if (a == b) *a == *b; 
+    if (a == b) ++a == ++b; 
+  } 
+}
+
          
+
+
          
+
          -4- ...
          
 
          
 
+
          postincrement_result operator++(X& r, int);
+
          
+
+
          
+
          
+-5- Effects: equivalent to { X tmp = r; ++r; return tmp; }.
+
          
+
          
+
+
          
 
-
          Proposed resolution:
          
 
 
 
 
 
 
          
-
          1084. Response to UK 250
          
-
          Section: 24.2.4 [forward.iterators] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-16
          
-
          View all other issues in [forward.iterators].
          
+
          1010. operator-= should use default in concept
          
+
          Section: 24.2.5 [random.access.iterators] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
+
          View all other issues in [random.access.iterators].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-
          Addresses UK 250
          
 
-
          
-A default implementation should be supplied for the post-increment
-operator to simplify implementation of iterators by users.
-
          
+
          Addresses UK 263
          
 
 
          
-Copy the Effects clause into the concept description as the default
-implementation. Assumes a default value for postincrement_result
+This requirement on operator-= would be better expressed as a default
+implementation in the concept, with a matching axiom.
 
          
 
 
          [
-Summit:
-]
          
-
-
          
-Howard will open an issue.
-
          
-
-
          [
-2009-06-07 Daniel adds:
+Batavia (2009-05):
 ]
          
 
-
 
          
-This issue cannot currently be resolved as suggested, because
-that would render auto-detection of the return type
-postincrement_result invalid, see 14.10.2.2 [concept.map.assoc]/4+5. The
-best fix would be to add a default type to that associated type, but
-unfortunately any default type will prevent auto-deduction of types of
-associated functions as quoted above. A corresponding core issue
-is in preparation.
+The proposed resolution should also remove
+paragraph 5 and the declaration that precedes it.
+Further, we should provide an axiom
+that captures the desired semantics.
+This may be a broader policy to be applied.
+Move to Open.
 
          
 
 
 
          Proposed resolution:
          
-
          [
-This wording assumes the acceptance of UK 251 / 1009.  Both
-wordings change the same paragraphs.
-]
          
-
-
 
          
-Change 24.2.4 [forward.iterators]:
+Change 24.2.5 [random.access.iterators]:
 
          
 
-
          
-
          concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> { 
-
-  MoveConstructible postincrement_result;
-  requires HasDereference<postincrement_result>
-        && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
-
-  postincrement_result operator++(X& r, int); {
-     X tmp = r;
-     ++r;
-     return tmp;
-  }
-
-  axiom MultiPass(X a, X b) { 
-    if (a == b) *a == *b; 
-    if (a == b) ++a == ++b; 
-  } 
+
          concept RandomAccessIterator<typename X> : BidirectionalIterator<X>, LessThanComparable<X> {
+  ...
+  X& operator-=(X& x, difference_type n) { return x += -n; }
+  ...
 }
 
          
 
@@ -26897,63 +30942,75 @@ Change 24.2.4 [forward.iterators]:
 
 
 
          
-
          1085. Response to UK 258
          
-
          Section: 24.2.5 [bidirectional.iterators] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-16
          
-
          View all other issues in [bidirectional.iterators].
          
-
          View all issues with NAD Concepts status.
          
+
          1013. Response to UK 305
          
+
          Section: 25.4.7 [alg.min.max] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
+
          View all other issues in [alg.min.max].
          
+
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
          Addresses UK 258
          
 
-
          
-A default implementation should be supplied for the post-decrement
-operator to simplify implementation of iterators by users.
-
          
+
          Addresses UK 305
          
 
 
          
-Copy the Effects clause into the concept description as the default
-implementation. Assumes a default value for postincrement_result
+The negative requirement on IsSameType is a hold-over from an earlier
+draught with a variadic template form of min/max algorith. It is no
+longer necessary.
 
          
 
 
          [
-Summit:
+Batavia (2009-05):
 ]
          
 
 
          
-Howard will open an issue.
+We agree with the proposed resolution.
+Move to Tentatively Ready.
 
          
 
 
          [
-2009-06-07 Daniel adds:
+2009-07 Frankfurt
 ]
          
 
 
 
          
-This issue cannot currently be resolved as suggested, because
-that would render auto-detection of the return type
-postdecrement_result invalid, see 1084.
+We believe this is NAD, but this needs to be reviewed against the
+post-remove-concepts draft.
 
          
 
 
+
 
          Proposed resolution:
          
+
          
+Change 25 [algorithms]:
+
          
+
+
          template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& min(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& max(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
+
          
 
 
          
-Change 24.2.5 [bidirectional.iterators]:
+Change 25.4.7 [alg.min.max], p1, p9 and p17:
 
          
 
-
          
-
          concept BidirectionalIterator<typename X> : ForwardIterator<X> { 
-  MoveConstructible postdecrement_result; 
-  requires HasDereference<postdecrement_result> 
-        && Convertible<HasDereference<postdecrement_result>::result_type, const value_type&> 
-        && Convertible<postdecrement_result, const X&>; 
-  X& operator--(X&); 
-  postdecrement_result operator--(X& r, int); {
-     X tmp = r;
-     --r;
-     return tmp;
-  }
-}
+
          template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& min(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  const T& max(const T& a, const T& b, Compare comp);
+...
+template<class T, StrictWeakOrder<auto, T> Compare>
+  requires !SameType<T, Compare> && CopyConstructible<Compare>
+  pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
 
          
 
 
@@ -26962,177 +31019,134 @@ Change 24.2.5 [bidirectional.iterators]:
 
 
 
          
-
          1086. Response to UK 284
          
-
          Section: 24.6 [stream.iterators] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          1015. Response to UK 199
          
+
          Section: X [concept.transform] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all other issues in [concept.transform].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-
          Addresses UK 284
          
+
+
          Addresses UK 199
          
 
 
          
-The stream iterators need constraining with concepts/requrires clauses.
+The requirement that programs do not supply concept_maps should
+probably be users do not supply their own concept_map
+specializations. The program will almost certainly supply
+concept_maps - the standard itself supplies a specialization
+for RvalueOf references. Note that the term program is
+defined in 3.5 [basic.link]p1 and makes no account of the
+standard library being treated differently to user written code.
 
          
 
 
          [
-Summit:
+2009-05-09 Alisdair adds:
 ]
          
 
-
          
-We agree. To be handled by Howard, Martin and PJ.
-
          
-
-
-
          Proposed resolution:
          
-
-
-
-
-
-
          
-
          1087. Response to UK 301
          
-
          Section: 25.4.5 [alg.replace] Status: NAD Concepts
- Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
-
          View all other issues in [alg.replace].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
-
          Addresses UK 301
          
 
+
          
 
          
-replace and replace_if have the requirement: OutputIterator<Iter,
-Iter::reference> Which implies they need to copy some values in the
-range the algorithm is iterating over. This is not however the case, the
-only thing that happens is const T&s might be copied over existing
-elements (hence the OutputIterator<Iter, const T&>.
+The same problem is present in the words added for the
+LvalueReference/RvalueReference concepts last meeting.
 
          
-
 
          
-Remove OutputIterator<Iter, Iter::reference> from replace
-and replace_if.
+With three subsections requiring the same constraint, I'm wondering if there
+is a better way to organise this section.
+Possible 20.2.1 -> 20.2.3 belong in the fundamental concepts clause in
+ [concept.support]?  While they can be implemented purely as a
+library feature without additional compiler support, they are pretty
+fundamental and we want the same restriction on user-concept maps as is
+mandated there.
 
          
+
          
 
 
          [
-Summit:
+Batavia (2009-05):
 ]
          
 
 
          
-We agree. To be handled by Howard.
+We agree with the issue,
+but believe the wording needs further improvement.
+We want to investigate current definitions for nomenclature such as
+"user" and "program."
+Move to Open pending the recommended investigation.
 
          
 
 
 
          Proposed resolution:
          
 
          
-Change in 25.2 [algorithms.syn] and 25.4.5 [alg.replace]:
+Change X [concept.transform] p2:
 
          
 
-
          template<ForwardIterator Iter, class T> 
-  requires OutputIterator<Iter, Iter::reference> 
-        && OutputIterator<Iter, const T&> 
-        && HasEqualTo<Iter::value_type, T> 
-  void replace(Iter first, Iter last, 
-               const T& old_value, const T& new_value); 
-
-template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T> 
-  requires OutputIterator<Iter, Iter::reference> 
-        && OutputIterator<Iter, const T&> 
-        && CopyConstructible<Pred> 
-  void replace_if(Iter first, Iter last,
-                  Pred pred, const T& new_value);
-
          
-
-
-
-
+
          
+-2- A program user shall not provide concept maps for
+any concept in 20.1.1.
+
          
 
-
          
-
          1092. Class template integral_constant should be a  constrained template
          
-
          Section: 20.6.3 [meta.help] Status: NAD Concepts
- Submitter: Daniel Krügler Opened: 2009-03-22  Last modified: 2009-07-15
          
-
          View all other issues in [meta.help].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
 
          
-A first step to change the type traits predicates to constrained templates is to
-constrain their common base template integral_constant. This can be done,
-without enforcing depending classes to be constrained as well, but not
-vice versa
-without brute force late_check usages. The following proposed resolution depends
-on the resolution of LWG issue 1019.
+Change  [concept.true] p2:
 
          
 
-
          [
-Batavia (2009-05):
-]
          
-
 
          
-Move to Open, pending a paper that looks at constraints
-for the entirety of the type traits
-and their relationship to the foundation concepts.
-We recommend this be deferred
-until after the next Committee Draft is issued.
+-2- Requires: a program user shall not
+provide a concept map for the True concept.
 
          
 
-
-
          Proposed resolution:
          
-
            
-
          1. 
-
            
-In 20.6.2 [meta.type.synop], Header <type_traits>
-synopsis change as indicated:
-
            
-
            namespace std {
-// 20.5.3, helper class:
-template <classIntegralConstantExpressionType T, T v> struct integral_constant;
-
            
-
            2. 
-
          2. 
 
            
-In 20.6.3 [meta.help] change as indicated:
+Change  [concept.classify] p2:
 
            
-
            template <classIntegralConstantExpressionType T, T v>
-struct integral_constant {
-  static constexpr T value = v;
-  typedef T value_type;
-  typedef integral_constant<T,v> type;
-  constexpr operator value_type() { return value; }
-};
-
            
-
            3. 
-
          
+
+
          
+-2- Requires: a programuser shall not provide concept
+maps for any concept in this section.
+
          
+
 
 
 
 
 
 
          
-
          1096. unconstrained rvalue ref parameters
          
-
          Section: 17 [library] Status: NAD Concepts
- Submitter: David Abrahams Opened: 2009-03-21  Last modified: 2009-07-16
          
-
          View other active issues in [library].
          
-
          View all other issues in [library].
          
+
          1016. Response to JP 33
          
+
          Section: X [concept.comparison] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all other issues in [concept.comparison].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
+
+
          Addresses JP 33
          
+
 
          
-TODO: Look at all cases of unconstrained rvalue ref parameters and check
-that concept req'ts work when T deduced as reference.
+LessThanComparable and EqualityComparable don't correspond to NaN. 
 
          
 
+
          Original proposed resolution:
          
+
 
          
- We found some instances where that was not done correctly and we figure
-   the possibility of deducing T to be an lvalue reference was probably
-   overlooked elsewhere.
+Apply concept_map to these concepts at FloatingPointType.
 
          
 
 
          [
-Batavia (2009-05):
+Post Summit, Alisdair adds:
 ]
          
 
+
 
          
-Move to Open, pending proposed wording from Dave for further review.
+
          
+I don't understand the proposed resolution - there is no such thing as a
+'negative' concept_map, and these concepts are auto concepts that match
+float/double etc. Also not clear how we are supposed to match values to
+concepts.
+
          
+
          
+Recommend NAD and treat as a subset of issue 902.
+
          
 
          
 
 
+
 
          Proposed resolution:
          
 
          
+Recommend NAD.
 
          
 
 
@@ -27140,177 +31154,152 @@ Move to Open, pending proposed wording from Dave for further review.
 
 
 
          
-
          1101. unique requirements
          
-
          Section: 25.4.9 [alg.unique] Status: NAD Editorial
- Submitter: Howard Hinnant Opened: 2009-04-25  Last modified: 2009-07-13
          
-
          View all other issues in [alg.unique].
          
-
          View all issues with NAD Editorial status.
          
+
          1017. Response to US 66
          
+
          Section: X [concept.regular] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
-
          
-From Message c++std-core-14160 Howard wrote:
-
          
 
-
          
-It was the intent of the rvalue reference proposal for unique to only require MoveAssignable:
-N1860.
-
          
+
          Addresses US 66
          
 
 
          
-And Pete replied:
+Application of the Regular concept to floating-point types appears to be
+controversial (see long discussion on std-lib reflector). 
 
          
 
-
          
-That was overridden by the subsequent changes made for concepts in
-N2573,
-which reimposed the C++03 requirements.
-
          
+
          Original proposed resolution:
          
 
 
          
-My impression is that this overwrite was a simple (unintentional) mistake.
-Wording below to correct it.
+State that the Regular concept does not apply to floating-point types. 
 
          
 
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+
 
          
 
          
-Howard notes this issue resolves a discrepancy between the synopsis
-and the description.
-
          
-
          
-Move to NAD Editorial.
+Recommend that we handle the same as JP 33 / 1016.
 
          
 
          
 
+
          [
+Post Summit, Alisdair adds:
+]
          
+
 
-
          Proposed resolution:
          
+
          
 
          
-Change 25.4.9 [alg.unique]:
+Recommend Open, and review after resolution of 902 and revised axiom
+feature.
 
          
+
          
 
-
          template<ForwardIterator Iter> 
-  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
-        && EqualityComparable<Iter::value_type> 
-  Iter unique(Iter first, Iter last); 
-
-template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> 
-  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
-        && CopyConstructible<Pred> 
-  Iter unique(Iter first, Iter last, Pred pred);
-
          
 
-
          
-Note that the synopsis in 25.2 [algorithms.syn] is already correct.
-
          
 
+
          Proposed resolution:
          
 
 
 
 
 
 
          
-
          1105. Shouldn't Range be an auto concept
          
-
          Section: 24.2.8 [iterator.concepts.range] Status: NAD Concepts
- Submitter: David Abrahams Opened: 2009-04-23  Last modified: 2009-07-15
          
+
          1018. Response to US 70
          
+
          Section: 20.6 [meta] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all other issues in [meta].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
 
+
          Addresses US 70
          
+
+
          
+Specifications now expressed via narrative text are more accurately and
+clearly expressed via executable code.
+
          
+
          
+Wherever concepts are available that directly match this section's type
+traits, express the traits in terms of the concepts instead of via
+narrative text. Where the type traits do not quite match the
+corresponding concepts, bring the two into alignment so as to avoid two
+nearly-identical notions.
+
          
+
 
          [
-2009-04-26 Herb adds:
+Summit:
 ]
          
 
 
 
          
 
          
-Here's a common example: We have many ISV customers who have built lots of
-in-house STL-like containers. Imagine that, for the past ten years, the user
-has been happily using his XYZCorpContainer<T> that has begin() and end()
-and an iterator typedef, and indeed satisfies nearly all of Container,
-though maybe not quite all just like valarray. The user upgrades to a
-range-enabled version of a library, and now lib_algo( xyz.begin(), xyz.end());
-no longer works -- compiler error.
+We think that this is a good idea, but it requires a lot of work. If someone
+submits a paper proposing specific changes, we would be happy to review it
+at the next meeting.
 
          
-
          
-Even though XYZCorpContainer matches the pre-conceptized version of the
-algorithm, and has been working for years, it appears the user has to write
-at least this:
-
          
-
          template<class T> concept_map Range<XYZCorpContainer<T>> {};
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1020. Response to UK 204
          
+
          Section: 20.6.7 [meta.trans.other] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-23
          
+
          View all other issues in [meta.trans.other].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 204
          
 
-template<class T> concept_map Range<const XYZCorpContainer<T>> {};
-
          
 
          
-Is that correct?
+It is not possible to create a variant union based on a parameter pack
+expansion, e.g. to implement a classic discriminated union template. 
 
          
+
+
          Original proposed resolutuion:
          
+
 
          
-But he may actually have to write this as we do for initializer list:
+Restore aligned_union template that was removed by LWG issue 856. 
 
          
-
          template<class T>
-concept_map Range<XYZCorpContainer<T>> {
-   typedef T* iterator;
-   iterator begin(XYZCorpContainer<T> c) { return c.begin(); }
-   iterator end(XYZCorpContainer<T> c) { return c.end(); }
-};
 
-template<class T>
-concept_map Range<const XYZCorpContainer<T>> {
-   typedef T* iterator;
-   iterator begin(XYZCorpContainer<T> c) { return c.begin(); }
-   iterator end(XYZCorpContainer<T> c) { return c.end(); }
-};
-
          
+
          [
+Summit:
+]
          
+
 
+
          
+Agree. The need for aligned_union is compelling enough to reinstate.
 
          
 
 
          [
-2009-04-28 Alisdair adds:
+Post Summit, Alisdair adds:
 ]
          
 
 
 
          
-
          
-I recommend NAD, although remain concerned about header organisation.
-
          
-
          
-A user container will satisfy the MemberContainer concept, which IS auto.
-There is a concept_map for all MemberContainers to Container, and then a
-further concept_map for all Container to Range, so the stated problem is not
-actually true.  User defined containers will automatically match the Range
-concept without explicitly declaring a concept_map.
-
          
-
          
-The problem is that they should now provide an additional two headers,
-<iterator_concepts> and <container_concepts>.
- The only difference from
-making Range an auto concept would be this reduces to a single header,
-<iterator_concepts>.
-
          
-
          
-I am strongly in favour of any resolution that tackles the issue of
-explicitly requiring concept headers to make these concept maps available.
-
          
+paper
+N2843
+proposes an extension to the [[align]] attribute
+that further diminishes the need for this template.  Recommend NAD.
 
          
 
 
          [
-Batavia (2009-05):
+2009-10 Santa Cruz:
 ]
          
 
+
 
          
-
          
-We observe there is a recent paper by Bjarne that overlaps this issue.
-
          
-
          
-Alisdair continues to recommend NAD.
-
          
-
          
-Move to Open, and recommend the issue be deferred until after the next
-Committee Draft is issued.
-
          
+Mark NAD as suggested.
 
          
 
 
+
 
          Proposed resolution:
          
 
 
@@ -27318,67 +31307,136 @@ Committee Draft is issued.
 
 
 
          
-
          1107. constructor shared_future(unique_future) by value?
          
-
          Section: 30.6.6 [future.shared_future] Status: NAD Editorial
- Submitter: Thomas J. Gritzan Opened: 2009-04-03  Last modified: 2009-07-13
          
-
          View other active issues in [future.shared_future].
          
-
          View all other issues in [future.shared_future].
          
+
          1022. Response to UK 212
          
+
          Section: 20.8.15.6 [util.dynamic.safety] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-03-12
          
+
          View all other issues in [util.dynamic.safety].
          
 
          View all issues with NAD Editorial status.
          
 
          Discussion:
          
-
          
-In the shared_future class definition in 30.6.6 [future.shared_future]
-the move constructor 
-that constructs a shared_future from an unique_future receives the 
-parameter by value. In paragraph 3, the same constructor receives it as 
-const value. 
-
          
+
+
          Addresses UK 212
          
 
 
          
-I think that is a mistake and the constructor should take a r-value 
-reference: 
+The pointer-safety API is nothing to do with smart pointers, so does not
+belong in 20.8.15 [util.smartptr]. In fact it is a set of language
+support features are really belongs in clause 18 [language.support], with the contents declared in a header that
+deals with language-support of memory management.
 
          
 
-
          shared_future(unique_future<R>&& rhs);
-
          
-
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+
 
          
+Agree in principle, but not with the proposed resolution. We believe it
+belongs either a subsection of either 20 [utilities] or 20.8 [memory]
+as part of the general reorganization of 20 [utilities]. The
+declaration should stay in
+<memory>.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1023. Response to DE 22
          
+
          Section: 20.7.15.2 [func.wrap.func] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-13
          
+
          View all other issues in [func.wrap.func].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses DE 22
          
+
+
          Related to issue 1114.
          
+
 
          
-We agree with the proposed resolution.
-
          
-
          
-Move to Tentatively Ready.
+The conditions for deriving from std::unary_function and
+std::binary_function are unclear: The condition would also be satisfied if
+ArgTypes were std::vector<T1>, because it (arguably)
+"contains" T1.
 
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+Agree. std::reference_wrapper has the same structure, and we
+suggest that std::function be presented in the same way as
+std::reference_wrapper.
 
          
 
 
          [
-2009-07-05 Daniel notes:
+2009-05-09 Alisdair adds:
 ]
          
 
 
 
          
-The proposed change has already been incorported into the current working draft
-N2914.
+Phrasing should be "publicly and
+unambiguously derived from" and probably back in reference_wrapper too.  Updated
+wording supplied.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We agree with the proposed wording.
+Move to NAD Editorial.
 
          
 
 
 
          Proposed resolution:
          
 
          
-Change the synopsis in 30.6.6 [future.shared_future]:
+(no changes to <functional> synopsis required)
 
          
 
-
          shared_future(unique_future<R>&& rhs);
+
          
+Change synopsis in Class template function 20.7.15.2 [func.wrap.func]:
+
          
+
+
          template<Returnable R, CopyConstructible... ArgTypes> 
+class function<R(ArgTypes...)> 
+  : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and see below
+                                      // ArgTypes contains T1
+  : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and see below
+                                      // ArgTypes contains T1 and T2
+{
+   ...
 
          
 
 
          
-Change the definition of the constructor in 30.6.6 [future.shared_future]:
+Add new p1/p2 before 20.7.15.2.1 [func.wrap.func.con]:
 
          
 
-
          shared_future(const unique_future<R>&& rhs);
-
          
+
          
+
          
+The template instantiation function<R(T1)> shall be publicly and
+unambiguously derived from 
+std::unary_function<T1,R> if and only if the template type parameter
+is a function type taking one argument of type T1 and returning R.
+
          
+
+
          
+The template instantiation function<R(T1,T2)> shall be publicly and
+unambiguously derived from 
+std::binary_function<T1,T2,R> if and only if the template type
+parameter is a function type taking two arguments of type T1 and T2 and
+returning R.
+
          
+
+
          explicit function();
+
          
+
          
 
 
 
@@ -27386,774 +31444,9192 @@ Change the definition of the constructor in 30.6.6 [future.shared_future]:
 
 
 
          
-
          1109. std::includes should require CopyConstructible predicate
          
-
          Section: 25.5.5.1 [includes] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-04-28  Last modified: 2009-07-13
          
-
          View all other issues in [includes].
          
+
          1024. Response to JP 39
          
+
          Section: 20.7.15.2 [func.wrap.func] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
+
          View all other issues in [func.wrap.func].
          
 
          View all issues with NAD Concepts status.
          
 
          Discussion:
          
+
+
          Addresses JP 39
          
+
 
          
-All the set operation algorithms require a CopyConstructible predicate, with
-the exception of std::includes.  This looks like a typo as much as anything,
-given the general library requirement that predicates are copy
-constructible, and wording style of other set-like operations.
+There are no requires corresponding to F of std::function.
 
          
 
+
          [
+2009-05-01 Daniel adds:
+]
          
+
+
+
          
+1070 removes the second constructor.
+
          
+
 
          [
 Batavia (2009-05):
 ]
          
 
 
          
 We agree with the proposed resolution.
-Move to NAD Editorial.
+Move to Tentatively Ready.
+If issue 1070 is accepted,
+the changes to the second constructor
+in this issue are moot.
+
          
+
+
          [
+2009-07 Frankfurt:
+]
          
+
+
+
          
+Constructors have no definition.
 
          
 
 
+
 
          Proposed resolution:
          
 
          
-Change 25.2 [algorithms.syn] and 25.5.5.1 [includes]:
+Correct as follows in 20.7.15.2 [func.wrap.func] (class definition)
 
          
 
-
          template<InputIterator Iter1, InputIterator Iter2,
-         typename CopyConstructible Compare>
-  requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
-        && Predicate<Compare, Iter2::value_type, Iter1::value_type>
-  bool includes(Iter1 first1, Iter1 last1,
-                Iter2 first2, Iter2 last2,
-                Compare comp);
+
           template<class F, Allocator Alloc>
+   requires ConstructibleWithAllocator<F, Alloc>
+     && call=Callable<F, ArgTypes...>
+     && Convertible<call::result_type, R>
+   function(allocator_arg_t, const Alloc&, F);
+ template<class F, Allocator Alloc>
+   requires ConstructibleWithAllocator<F,Alloc>
+     && call=Callable<F, ArgTypes...>
+     && Convertible<call::result_type, R>
+   function(allocator_arg_t, const Alloc&, F&&);
 
          
 
 
 
 
 
+
 
          
-
          1111. associative containers underconstrained
          
-
          Section: 23.4 [associative] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-04-29  Last modified: 2009-07-16
          
-
          View all other issues in [associative].
          
-
          View all issues with NAD Concepts status.
          
+
          1025. Response to UK 208
          
+
          Section: 20.7.16 [unord.hash] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-03-12
          
+
          View other active issues in [unord.hash].
          
+
          View all other issues in [unord.hash].
          
+
          View all issues with NAD Future status.
          
 
          Discussion:
          
+
+
          Addresses UK 208
          
+
 
          
-According to table 87 (n2857) the expression X::key_equal for an unordered
-container shall return a value of type Pred, where Pred is an equivalence
-relation.
+std::hash should be implemented for much more of the standard
+library. In particular for pair, tuple and all the
+standard containers.
 
          
 
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1026. Response to UK 209
          
+
          Section: 20.8 [memory] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all other issues in [memory].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses UK 209
          
+
 
          
-However, all 4 containers constrain Pred to be merely a Predicate,
-and not EquivalenceRelation.
+Smart pointers cannot be used in constrained templates.
 
          
 
 
          [
-Batavia (2009-05):
+Summit:
 ]
          
 
+
 
          
-
          
-We agree with the proposed resolution.
-
          
-
          
-Move to Review.
-
          
+We look forward to a paper on this topic. We recommend no action until a
+paper is available. We understand that a paper is forthcoming.
+
          
+
+
          [
+Peter Dimov adds:
+]
          
+
+
+
          
+shared_ptr<T> and weak_ptr<T> support all
+types T for which T* is valid. In other words, a
+possible (partial) resolution is to change class T to
+PointeeType T for shared_ptr, weak_ptr and
+possibly enable_shared_from_this.
 
          
 
 
+
 
          Proposed resolution:
          
-
          
-For ordered containers, replace 
-
          
-
          Predicate<auto, Key, Key> Compare = less<Key>
-
          
-
          
-with 
-
          
-
          StrictWeakOrder<auto, Key, Key> Compare = less<Key>
-
          
+
+
+
+
+
+
          
+
          1027. Response to UK 213
          
+
          Section: 20.8.8 [default.allocator] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-15
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses UK 213
          
 
 
          
-For unordered containers, replace 
+std::allocator should be constrained to simplify its use on constrained
+contexts. This library component models allocation from free store via the
+new operator so choose constraints to 
+match. The Allocator concept allows for a wider variety of allocators that
+users may choose to supply if their allocation model does not require
+operator new, without impacting the 
+requirements of this template. 
 
          
-
          Predicate<auto, Key, Key> Compare = less<Key>
-
          
+
 
          
-with 
+Suggested direction:
 
          
-
          EquivalenceRelation<auto, Key, Key> Compare = less<Key>
-
          
 
          
-As in the following declarations:
+The primary allocator template should be constrained to require
+ObjectType<T> and FreeStoreAllocatable<T>.
+Further operations to be constrained as required.
 
          
 
+
          [
+Summit:
+]
          
+
+
 
          
-
          
-Associative containers 23.4 [associative]
-
          
-
          
- 1 Headers <map> and <set>:
-
          
-
          
-   Header <map> synopsis
-
          
-
             namespace std {
-     template <ValueType Key, ValueType T,
-               PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-               Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-       requires NothrowDestructible<Key> && NothrowDestructible<T>
-             && CopyConstructible<Compare>
-             && AllocatableElement<Alloc, Compare, const Compare&>
-             && AllocatableElement<Alloc, Compare, Compare&&>
-     class map;
+Agree as stated. A future paper will address additional related issues.
+
          
 
-     ...
 
-     template <ValueType Key, ValueType T,
-               PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-               Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-       requires NothrowDestructible<Key> && NothrowDestructible<T>
-             && CopyConstructible<Compare>
-             && AllocatableElement<Alloc, Compare, const Compare&>
-             && AllocatableElement<Alloc, Compare, Compare&&>
-     class multimap;
 
-     ...
+
          Proposed resolution:
          
 
-   }
-
          
 
-
          
-   Header <set> synopsis
-
          
-
             namespace std {
-     template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-               Allocator Alloc = allocator<Key> >
-       requires NothrowDestructible<Key> && CopyConstructible<Compare>
-             && AllocatableElement<Alloc, Compare, const Compare&>
-             && AllocatableElement<Alloc, Compare, Compare&&>
-     class set;
 
-     ...
 
-     template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-               Allocator Alloc = allocator<Key> >
-       requires NothrowDestructible<Key> && CopyConstructible<Compare>
-             && AllocatableElement<Alloc, Compare, const Compare&>
-             && AllocatableElement<Alloc, Compare, Compare&&>
-     class multiset;
 
-     ...
+
          
+
          1028. Response to UK 214
          
+
          Section: 20.8.10 [storage.iterator] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
 
-   }
-
          
+
          Addresses UK 214
          
 
 
          
- 23.4.1p2 Class template map [map]
+raw_storage_iterator needs constraining as an iterator adaptor to be safely
+used in constrained templates 
 
          
-
           namespace std {
-   template <ValueType Key, ValueType T,
-             PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-     requires NothrowDestructible<Key> && NothrowDestructible<T>
-           && CopyConstructible<Compare>
-           && AllocatableElement<Alloc, Compare, const Compare&>
-           && AllocatableElement<Alloc, Compare, Compare&&>
-   class map {
-     ...
-   };
- }
-
          
 
+
          [
+Summit:
+]
          
 
-
          
- 23.4.2p2 Class template multimap [multimap]
-
          
-
           namespace std {
-   template <ValueType Key, ValueType T,
-             PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-     requires NothrowDestructible<Key> && NothrowDestructible<T>
-           && CopyConstructible<Compare>
-           && AllocatableElement<Alloc, Compare, const Compare&>
-           && AllocatableElement<Alloc, Compare, Compare&&>
-   class multimap {
-     ...
-   };
- }
-
          
+
+
          
+We look forward to a paper on this topic. We recommend no action until a
+paper is available.
+
          
+
+
          [
+Post Summit Alisdair provided wording and rationale.
+]
          
 
 
-
          
- 23.4.3p2 Class template set [set]
-
          
-
           namespace std {
-   template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-             Allocator Alloc = allocator<Key> >
-     requires NothrowDestructible<Key> && CopyConstructible<Compare>
-           && AllocatableElement<Alloc, Compare, const Compare&>
-           && AllocatableElement<Alloc, Compare, Compare&&>
-   class set {
-     ...
-   };
- }
-
          
 
 
+
          Proposed resolution:
          
 
          
- 23.4.4p2 Class template multiset [multiset]
+20.8 [memory] p2
 
          
-
           namespace std {
-   template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
-             Allocator Alloc = allocator<Key> >
-     requires NothrowDestructible<Key> && CopyConstructible<Compare>
-           && AllocatableElement<Alloc, Compare, const Compare&>
-           && AllocatableElement<Alloc, Compare, Compare&&>
-   class multiset {
-     ...
-   };
- }
+
          
+Update the synopsis for <memory>
+
          
+
          // 20.7.8, raw storage iterator:
+template <class ForwardIterator OutputIterator, class ObjectType T> 
+  requires OutputIterator< OutIter, T >
+    class raw_storage_iterator;
+
+template <ForwardIterator OutIter, ObjectType T> 
+  requires OutputIterator< OutIter, T >
+  concept_map Iterator<raw_storage_iterator< OutIter, T > > { }
 
          
 
+
 
          
- 23.5 Unordered associative containers [unord]
+20.8.10 [storage.iterator] p1
 
          
 
          
- 1 Headers <unordered_map> and <unordered_set>:
+Replace class template definition with:
 
          
+
          namespace std { 
+  template <class ForwardIterator OutputIterator, class ObjectType T> 
+    requires OutputIterator< OutIter, T >
+  class raw_storage_iterator 
+    : public iterator<output_iterator_tag,void,void,void,void> { 
+  public: 
+    explicit raw_storage_iterator(OutputIterator x); 
+
+    raw_storage_iterator<OutputIterator,T>& operator*(); 
+    raw_storage_iterator<OutputIterator,T>& operator=(const T& element); 
+    raw_storage_iterator<OutputIterator,T>& operator++(); 
+    raw_storage_iterator<OutputIterator,T> operator++(int); 
+  }; 
+
+  template <ForwardIterator OutIter, ObjectType T> 
+    requires OutputIterator< OutIter, T >
+    concept_map Iterator<raw_storage_iterator< OutIter, T > > { }
+}
+
          
+
+
+
          Rationale:
          
+
          
+raw_storage_iterator has to adapt a ForwardIterator,
+rather than just an InputIterator for two reasons:
+
          
+
+
            
+
          1. 
+The initial iterator passed by value is expected to remain valid,
+pointing to the initialized region of memory.
+
            2. 
+
          2. 
+to avoid breaking the declaration of post-increment operator which would
+require some kind of proxy formulation to support generalised InputIterators.
+
            3. 
+
          
+
+
+
+
+
+
+
          
+
          1029. Response to UK 210
          
+
          Section: 20.8.13 [specialized.algorithms] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
+
          View all other issues in [specialized.algorithms].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses UK 210
          
+
+
          Related to 582
          
+
+
          
+Specialized algorithms for memory managenment need requirements to be
+easily usable in constrained templates.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+We look forward to a paper on this topic. We recommend no action until a
+paper is available.
+
          
+
+
          [
+Post Summit Alisdair provided wording.
+]
          
+
+
+
          [
+Post Summit:
+]
          
+
+
+
          
+
          
+Daniel adds:
+
          
+
+
          
+
            
+
          1. 
+I suggest Size should require IntegralLike and not UnsignedIntegralLike,
+because otherwise simple int-literals could not be provided as arguments
+and it would conflict with other algorithms that only require IntegralLike.
+
            2. 
+
          2. 
+
            
+The current for-loop-test relies on evaluation in boolean context which is
+not provided by ArithmeticLike and it's refinements. I propose to change the
+corresponding for-loop-headers to:
+
            
+
              
+
            1. 
+for uninitialized_copy_n: for ( ; n > Size(0); ++result, ++first, --n) {
+
              2. 
+
            2. 
+for uninitialized_fill_n: for (; n > Size(0); ++first, --n) {
+
              3. 
+
            
+
            3. 
+
          
+
          
+
+
          
+Alisdair adds:
+
          
+
          
+For the record I agree with Daniel's suggestion.
+
          
+
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+20.8 [memory] p2
+
          
+
          
+Update the synopsis for <memory>
+
          
+
          template <class InputIterator InIter,
+         class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+   requires ForwardIterator<OutIter>
+   ForwardIterator OutIter
+   uninitialized_copy(InputIterator InIter first, InputIterator InIter last, 
+                      ForwardIterator OutIter result);
+
+template <class InputIterator InIter,
+          class IntegralLike Size,
+          class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+  requires ForwardIterator<OutIter>
+  ForwardIterator OutIter
+  uninitialized_copy_n(InputIterator InIter first, Size n, 
+                       ForwardIterator OutIter result);
+
+template <class ForwardIterator Iter, class ObjectType T>
+  requires Constructible< Iter::value_type, const T& >
+  void uninitialized_fill(ForwardIterator Iter first, ForwardIterator Iter last, 
+                          const T& x);
+
+template <class ForwardIterator Iter, class IntegralLike Size, class ObjectType T> 
+  requires Constructible< Iter::value_type, const T& >
+  void
+  uninitialized_fill_n(ForwardIterator Iter first, Size n, const T& x);
+
          
+
+
          
+Update as follows:
+
          
+
+
          
+uninitialized_copy 20.8.13.2 [uninitialized.copy]
+
          
+
+
          template <class InputIterator InIter,
+         class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+   requires ForwardIterator<OutIter>
+   ForwardIterator OutIter
+   uninitialized_copy(InputIterator InIter first, InputIterator InIter last, 
+                      ForwardIterator OutIter result);
+
          
+
+
          
+
          
+-1- Effects:
+
          
+
          for (; first != last; ++result, ++first)  {
+   new (static_cast<void*>(&*result))
+       typename iterator_traits<ForwardIterator> OutIter::value_type(*first);
+}
+
          
+
+
          
+-2- Returns: result
+
          
+
+
          
+
+
          template <class InputIterator InIter,
+          class IntegralLike Size,
+          class ForwardIterator OutputIterator<auto, InIter::reference> OutIter> 
+  requires ForwardIterator<OutIter>
+  ForwardIterator OutIter
+  uninitialized_copy_n(InputIterator InIter first, Size n, 
+                       ForwardIterator OutIter result);
+
          
+
+
          
+
          
+-3- Effects:
+
          
+
          for ( ; n > Size(0); ++result, ++first, --n) {
+   new (static_cast<void*>(&*result))
+       typename iterator_traits<ForwardIterator> OutIter::value_type(*first);
+}
+
          
+
          
+-4- Returns: result
+
          
+
          
+
+
          
+
+
+
          
+uninitialized_fill 20.8.13.3 [uninitialized.fill]
+
          
+
+
          template <class ForwardIterator Iter, class ObjectType T>
+  requires Constructible< Iter::value_type, const T& >
+  void uninitialized_fill(ForwardIterator Iter first, ForwardIterator Iter last, 
+                          const T& x);
+
          
+
+
          
+
          
+-1- Effects:
+
          
+
          for (; first != last; ++first) {
+   new ( static_cast<void*>( &*first) ) 
+       typename iterator_traits<ForwardIterator> Iter::value_type(x);
+}
+
          
+
          
+
          
+
+
+
          
+uninitialized_fill_n 20.8.13.4 [uninitialized.fill.n]
+
          
+
+
          template <class ForwardIterator Iter, class IntegralLike Size, class ObjectType T> 
+  requires Constructible< Iter::value_type, const T& >
+  void
+  uninitialized_fill_n(ForwardIterator Iter first, Size n, const T& x);
+
          
+
+
          
+
          
+-1- Effects:
+
          
+
          for (; n-- > Size(0); ++first, --n) {
+   new ( static_cast<void*>( &*first) ) 
+       typename iterator_traits<ForwardIterator> Iter::value_type(x);
+}
+
          
+
          
+
          
+
+
+
+
+
+
+
          
+
          1031. Response to US 78
          
+
          Section: 20.8.15.2 [util.smartptr.shared] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-20
          
+
          View all other issues in [util.smartptr.shared].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
+
          Addresses US 78
          
+
+
          
+There is presently no way to convert directly from a shared_ptr to a
+unique_ptr. Add an interface that performs the conversion. 
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+We look forward to a paper on this topic. We recommend no action until a
+paper is available. We believe that the shared pointer must use the default
+deleter for the conversion to succeed.
+
          
+
+
          [
+Peter Dimov adds:
+]
          
+
+
+
          
+This is basically a request for shared_ptr<>::release in
+disguise, with all the associated problems. Not a good idea.
+
          
+
+
          [
+2009-07 post-Frankfurt:
+]
          
+
+
+
          
+
          
+The rationale for the omission of a release() member function from shared_ptr is given in:
+http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm
+
          
+
          
+The implementation of such a member is non-trivial (and maybe
+impossible), because it would need to account for the deleter.
+
          
+
          
+
+
          [
+2009-07-26 Howard sets to Tentatively NAD Future.
+]
          
+
+
+
          
+
          
+I took an online poll and got 3 votes for NAD and 3 for NAD Future.  Personally
+I prefer NAD Future as this does refer to an extension that could conceivably be
+considered beyond C++0X.
+
          
+
+
          
+However such an extension would need to solve a couple of problems:
+
          
+
+
            
+
          1. What is the interface for such a conversion when the shared_ptr does
+not have unique ownership?  Throw an exception?  Create a null unique_ptr?
+Undefined behavior?
+
            2. 
+
+
          2. 
+
            
+How does one handle custom deleters given to the shared_ptr constructor?
+
            
+
            
+I do not believe it is possible to implement a general answer to this question.
+The shared_ptr deleter is a run time (or construction time) characteristic.
+The unique_ptr deleter is a compile time characteristic.  In general one
+can not know to what type of unqiue_ptr you are converting to.
+
            
+
            
+One answer is for the user of the conversion to specify the deleter type and perhaps
+throw an exception if the specification turns out to be incorrect.
+
            
+
            
+Another answer is for the conversion to only be valid when the underlying deleter
+is default_delete.  We would probalby need to specify that this is indeed the
+underlying deleter of a shared_ptr when a custom deleter is not given in
+the constructor.
+
            
+
            3. 
+
          
+
+
          
+At any rate, there are non-trivial design issues which would need to be implemented
+and tested in the field for usability prior to standardization.
+
          
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+Moved to NAD Future.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1032. Response to JP 45
          
+
          Section: 20.9 [time] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-16
          
+
          View all other issues in [time].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses JP 45
          
+
+
          
+Rep, Period, Clock and Duration
+don't correspond to concept.
+
          
+
          template <class Rep, class Period = ratio<1>> class duration; 
+template <class Clock, class Duration = typename Clock::duration> class time_point; 
+
          
+
          
+Make concept for Rep, Period, Clock and Duration.
+Fix 20.9 [time] and wait_until
+and wait_for's template parameter at 30 [thread]. 
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+We agree that this section needs concepts. We look forward to a paper on
+this topic. We recommend no action until a paper is available.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1035. Response to UK 226
          
+
          Section: 23.2.1 [container.requirements.general] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-20
          
+
          View other active issues in [container.requirements.general].
          
+
          View all other issues in [container.requirements.general].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 226
          
+
+
          
+<array> must be added to this list. In particular it
+doesn't satisfy: - no swap() function invalidates any
+references, pointers, or iterators referring to the elements of the
+containers being swapped. and probably doesn't satisfy: - no
+swap() function throws an exception.
+
          
+
          
+If <array> remains a container, this will have to also
+reference array, which will then have to say which of these
+points it satisfies.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+Agree. The proposed resolution is incomplete. Further work required.
+
          
+
+
          [
+2009-05-01 Daniel adds:
+]
          
+
+
+
          
+Issue 1099 also suggests
+adding move constructor to this.
+
          
+
+
          [
+2009-07 post-Frankfurt:
+]
          
+
+
+
          
+Howard is to draft a note that explains what happens to references.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD.  No consensus for change.
+
          
+
+
+
+
          [
+2009-08-01 Howard provided wording.
+]
          
+
+
+
          Proposed resolution:
          
+
          
+Add a paragraph to 23.3.1.2 [array.special]:
+
          
+
+
          template <Swappable T, size_t N> void swap(array<T,N>& x, array<T,N>& y);
+
          
+
          
+
          
+Effects:
+
          
+
          swap_ranges(x.begin(), x.end(), y.begin());
+
          
+
+
          
+[Note:
+Outstanding iterators, references and pointers may be invalidated.
+— end note]
+
          
+
          
+
          
+
+
+
+
+
+
          
+
          1036. Response to UK 231
          
+
          Section: 23.2.3 [sequence.reqmts] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-15
          
+
          View other active issues in [sequence.reqmts].
          
+
          View all other issues in [sequence.reqmts].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses UK 231
          
+
+
          
+p9-p11 are redundant now that Concepts define what it means to be an
+Iterator and guide overload resolution accordingly. 
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+Agree with issue and change to 23.2.3 [sequence.reqmts]. The
+changes required to 21 [strings] will be part of the general
+concept support for that clause.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Strike 23.2.3 [sequence.reqmts]p9-11. Make sure std::basic_string
+has constraints similar to
+std::vector to meet this old guarantee. 
+
          
+
+
+
+
+
+
          
+
          1041. Response to UK 239
          
+
          Section: 23.2.4 [associative.reqmts] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-20
          
+
          View other active issues in [associative.reqmts].
          
+
          View all other issues in [associative.reqmts].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
+
          Addresses UK 239
          
+
+
          
+It is not possible to take a move-only key out of an unordered
+container, such as (multi)set or
+(multi)map, or the new unordered containers.
+
          
+
+
          
+Add below a.erase(q), a.extract(q), with the following notation:
+
          
+
          
+a.extract(q)>, Return type pair<key, iterator>
+Extracts the element pointed to by q and erases it from the
+set. Returns a pair containing the value pointed to by
+q and an iterator pointing to the element immediately
+following q prior to the element being erased. If no such
+element exists,returns a.end().
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+We look forward to a paper on this topic. We recommend no action until a
+paper is available. The paper would need to address exception safety.
+
          
+
+
          [
+Post Summit Alisdair adds:
+]
          
+
+
+
          
+Would value_type be a better return type than key_type?
+
          
+
+
          [
+2009-07 post-Frankfurt:
+]
          
+
+
+
          
+Leave Open. Alisdair to contact Chris Jefferson about this.
+
          
+
+
          [
+2009-09-20 Howard adds:
+]
          
+
+
+
          
+See the 2009-09-19 comment of 839 for an API which
+accomplishes this functionality and also addresses several other use
+cases which this proposal does not.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD Future. No consensus to make the change at this time.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+In 23.2.4 [associative.reqmts] Table 85, add:
+
          
+
+
          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
          Table 85 --  Associative container requirements (in addition to container)
          ExpressionReturn typeAssertion/note
          pre-/post-condition          		Complexity
          a.erase(q).........
          a.extract(q)pair<key_type, iterator>Extracts the element pointed to by q and erases it from the set. 
+Returns a pair containing the value pointed to by q and an iterator
+pointing to the element immediately following q prior to the element being
+erased. If no such element 
+exists, returns a.end().amortized constant
          
+
          
+
+
          
+In 23.2.5 [unord.req] Table 87, add:
+
          
+
+
          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
          Table 87 -- Unordered associative container requirements (in addition to container)
          ExpressionReturn typeAssertion/note
          pre-/post-condition          		Complexity
          a.erase(q).........
          a.extract(q)pair<key_type, iterator>Extracts the element pointed to by q and erases it from the set. 
+Returns a pair containing the value pointed to by q and an iterator
+pointing to the element immediately following q prior to the element being
+erased. If no such element 
+exists, returns a.end().amortized constant
          
+
          
+
+
+
+
+
+
          
+
          1042. Response to UK 244
          
+
          Section: 23.3 [sequences] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-23
          
+
          View all other issues in [sequences].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 244
          
+
+
          
+The validity of the expression &a[n] == &a[0] + n is contingent on
+operator& doing the "right thing" (as captured by the CopyConstructible
+requirements in table 30 in C++2003). However this constraint has been
+lost in the Concepts of C++0x. This applies to vector and array (it
+actually applies to string also, but that's a different chapter, so I'll
+file a separate comment there and cross-reference).
+
          
+
+
          
+Suggested solution:
+
          
+
+
          
+Define a ContiguousStrorage and apply it to
+vector, array and string.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+Agree with the issue but not the details of the proposed solution. Walter to
+provide wording for the new concept.
+
          
+
+
          [
+Post Summit Alisdair adds:
+]
          
+
+
+
          
+Another LWG subgroup wondered if this concept
+should extend to complex<T>, and so not be built on the container concept at
+all?
+
          
+
+
          [
+2009-07 post-Frankfurt:
+]
          
+
+
+
          
+Leave Open, pending a post-Concepts Working Draft.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark issue 1042 as NAD, in rationale state that this was solved by removal of concepts.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Add to <container_concepts> synopsis in  [container.concepts]
+
          
+
+
          concept< typename C > ContiguousStorageContainer see below;
+
          
+
+
          
+Add a new section to the end of  [container.concepts]
+
          
+
+
          
+
          
+23.1.6.x ContiguousStorageContainer concept [container.concepts.contiguous]
+
          
+
+
          concept ContiguousStorageContainer< typename C >
+  : Container<C>
+{
+  value_type* data(C&);
+
+  axiom Contiguity(C& c, size_type i) {
+    if( i < size(c) ) {
+         addressof( * (data(c) + i) )
+      == addressof( * advance(data(c), i) );
+    }
+  }
+}
+
          
+
+
          
+The ContiguousStorageContainer concept describes a container whose elements
+are allocated in a single region of memory, and are stored sequentially
+without intervening padding other than to meet alignment requirements.
+For example, the elements may be stored in a
+single array of suitable length.
+
          
+
+
          value_type * data( C& );
+
          
+
+
          
+Returns: a pointer to the first element in the region of storage.
+Result is unspecified for an empty container.
+
          
+
+
          
+
+
          
+Change 23.3.1 [array] p1:
+
          
+
+
          
+-1- The header <array> defines a class template for
+storing fixed-size sequences of objects. An array supports
+random access iterators. An instance of array<T, N>
+stores N elements of type T, so that size() ==
+N is an invariant. The elements of an array are stored
+contiguously, meaning that if a is an
+array<T, N> then it obeys the identity &a[n]
+== &a[0] + n for all 0 <= n < N
+satisfies the concept ContiguousStorageContainer< array<T,
+N>>.
+
          
+
+
          
+Add to the synopsis in 23.3.1 [array]:
+
          
+
+
              ...
+    T * data(); 
+    const T * data() const; 
+  };
+
+  template< typename T, size_t N >
+    concept_map ContiguousStorageContainer< array<T, N>> {};
+} 
+
          
+
+
          
+Change 23.3.6 [vector] p1:
+
          
+
+
          
+A vector is a sequence container that supports random access
+iterators. In addition, it supports (amortized) constant time insert and
+erase operations at the end; insert and erase in the middle take linear
+time. Storage management is handled automatically, though hints can be
+given to improve efficiency. The elements of a vector are stored
+contiguously, meaning that if v is a
+vector<T, Alloc> (where T is some
+type other than bool), then it obeys the
+identity &v[n] == &v[0] + n for all 0 <= n <
+v.size() satisfies the concept ContiguousStorageContainer<
+vector< T, Alloc>>.
+
          
+
+
          
+Add at the end of the synopsis in 23.3.6 [vector] p2:
+
          
+
+
          template< typename T, typename A >
+  requires !SameType< T, bool >
+  concept_map ContiguousStorageContainer< vector<T, A>> {};
+
          
+
+
+
+
          Rationale:
          
+Solved by removal of concepts.
+
+
+
+
+
+
          
+
          1043. Response to US 91
          
+
          Section: 29.6 [atomics.types.operations] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [atomics.types.operations].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses US 91
          
+
+
          
+It is unclear whether or not a failed compare_exchange is a RMW operation
+(as used in 1.10 [intro.multithread]).
+
          
+
+
          
+Suggested solution:
+
          
+
+
          
+Make failing compare_exchange operations not be RMW.
+
          
+
+
          [
+Anthony Williams adds:
+]
          
+
+
+
          
+In 29.6 [atomics.types.operations] p18 it says that "These
+operations are atomic read-modify-write operations" (final sentence).
+This is overly restrictive on the implementations of
+compare_exchange_weak and compare_exchange_strong on platforms without a
+native CAS instruction.
+
          
+
+
+
          [
+Summit:
+]
          
+
+
+
          
+Group agrees with the resolution as proposed by Anthony Williams in the attached note.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We recommend the proposed resolution be reviewed
+by members of the Concurrency Subgroup.
+
          
+
+
          [
+2009-07 post-Frankfurt:
+]
          
+
+
+
          
+This is likely to be addressed by Lawrence's upcoming paper. He will
+adopt the proposed resolution.
+
          
+
+
          [
+2009-08-17 Handled by
+N2925.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2992.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Change 29.6 [atomics.types.operations] p18:
+
          
+
+
          
+-18- Effects: Atomically, compares the value pointed to by
+object or by this for equality with that in
+expected, and if true, replaces the value pointed to by
+object or by this with desired, and if false, updates
+the value in expected with the value pointed to by
+object or by this. Further, if the comparison is true,
+memory is affected according to the value of success, and if the
+comparison is false, memory is affected according to the value of
+failure. When only one memory_order argument is
+supplied, the value of success is order, and the value
+of failure is order except that a value of
+memory_order_acq_rel shall be replaced by the value
+memory_order_acquire and a value of
+memory_order_release shall be replaced by the value
+memory_order_relaxed. If the comparison is true, 
+Tthese operations are atomic
+read-modify-write operations (1.10). 
+If the comparison is false, these
+operations are atomic load operations.
+
          
+
+
+
+
+
+
+
          
+
          1046. Response to UK 329
          
+
          Section: 30.6 [futures] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [futures].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 329
          
+
+
          
+future, promise and packaged_task provide a
+framework for creating future values, but a simple function to tie all
+three components together is missing. Note that we only need a *simple*
+facility for C++0x. Advanced thread pools are to be left for TR2.
+
          
+
+
          
+Simple Proposal:
+
          
+
+
          
+Provide a simple function along the lines of: 
+
          
+
          template< typename F, typename ... Args >
+  requires Callable< F, Args... >
+    future< Callable::result_type > async( F&& f, Args && ... ); 
+
          
+
+
          
+Semantics are similar to creating a thread object with a packaged_task
+invoking f with forward<Args>(args...)
+but details are left unspecified to allow different scheduling and thread
+spawning implementations. 
+
          
+
          
+It is unspecified whether a task submitted to async is run on its own thread
+or a thread previously used for another async task. If a call to async
+succeeds, it shall be safe to wait for it from any thread. 
+
          
+
          
+The state of thread_local variables shall be preserved during async calls. 
+
          
+
          
+No two incomplete async tasks shall see the same value of
+this_thread::get_id(). 
+
          
+
          
+[Note: this effectively forces new tasks to be run on a new thread, or a
+fixed-size pool with no queue. If the 
+library is unable to spawn a new thread or there are no free worker threads
+then the async call should fail. --end note] 
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+The concurrency subgroup has revisited this issue and decided that it
+could be considered a defect according to the Kona compromise. A task
+group was formed lead by Lawrence Crowl and Bjarne Stroustrup to write a
+paper for Frankfort proposing a simple asynchronous launch facility
+returning a future. It was agreed that the callable must be run on a
+separate thread from the caller, but not necessarily a brand-new thread.
+The proposal might or might not allow for an implementation that uses
+fixed-size or unlimited thread pools.
+
          
+
          
+Bjarne in c++std-lib-23121: I think that what we agreed was that to
+avoid deadlock async() would almost certainly be specified to  launch in
+a different thread from the thread that executed async(), but I don't
+think it was a specific design constraint.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Proposed resolution: see
+N2996
+(Herb's and Lawrence's paper on Async). Move state to NAD editorial.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1047. Response to UK 334
          
+
          Section: 30.6.6 [futures.unique_future] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [futures.unique_future].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 334
          
+
+
          
+Behaviour of get() is undefined if calling get() while
+not is_ready(). The intent is that get() is a blocking
+call, and will wait for the future to become ready.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+Agree, move to Review.
+
          
+
          
+
+
          [
+2009-04-03 Thomas J. Gritzan adds:
+]
          
+
+
+
          
+
          
+This issue also applies to shared_future::get().
+
          
+
+
          
+Suggested wording:
+
          
+
+
          
+Add a paragraph to  [futures.shared_future]:
+
          
+
+
          void shared_future<void>::get() const;
+
          
+
          
+Effects: If is_ready() would return false, block on the asynchronous 
+result associated with *this.
+
          
+
          
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+It is not clear to us that this is an issue,
+because the proposed resolution's Effects clause seems to duplicate
+information already present in the Synchronization clause.
+Keep in Review status.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Add a paragraph to 30.6.6 [futures.unique_future]:
+
          
+
+
          R&& unique_future::get(); 
+R& unique_future<R&>::get(); 
+void unique_future<void>::get();
+
          
+
          
+
          Note:...
          
+
          
+Effects: If is_ready() would return false,
+block on the asynchronous result associated with *this.
+
          
+
          
+Synchronization: if *this is associated with a
+promise object, the completion of set_value() or
+set_exception() to that promise happens before (1.10)
+get() returns.
+
          
+
          
+
          
+
+
+
+
+
+
          
+
          1048. Response to UK 335
          
+
          Section: 30.6.6 [futures.unique_future] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [futures.unique_future].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 335
          
+
+
          
+std::unique_future is MoveConstructible, so you can transfer the
+association with an asynchronous result from one instance to another.
+However, there is no way to determine whether or not an instance has
+been moved from, and therefore whether or not it is safe to wait for it.
+
          
+
+
          std::promise<int> p;
+std::unique_future<int> uf(p.get_future());
+std::unique_future<int> uf2(std::move(uf));
+uf.wait(); // oops, uf has no result to wait for. 
+
          
+
+
          
+Suggest we add a waitable() function to unique_future
+(and shared_future) akin to std::thread::joinable(),
+which returns true if there is an associated result to wait for
+(whether or not it is ready).
+
          
+
+
          
+Then we can say:
+
          
+
+
          if(uf.waitable()) uf.wait();
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+Create an issue. Requires input from Howard. Probably NAD.
+
          
+
          
+
+
          [
+Post Summit, Howard thows in his two cents:
+]
          
+
+
+
          
+
          
+Here is a copy/paste of my last prototype of unique_future which was
+several years ago.  At that time I was calling unique_future future:
+
          
+
+
          template <class R>
+class future
+{
+public:
+    typedef R result_type;
+private:
+    future(const future&);// = delete;
+    future& operator=(const future&);// = delete;
+
+    template <class R1, class F1> friend class prommise;
+public:
+    future();
+    ~future();
+
+    future(future&& f);
+    future& operator=(future&& f);
+
+    void swap(future&& f);
+
+    bool joinable() const;
+    bool is_normal() const;
+    bool is_exceptional() const;
+    bool is_ready() const;
+
+    R get();
+
+    void join();
+    template <class ElapsedTime>
+        bool timed_join(const ElapsedTime&);
+};
+
          
+
+
          
+shared_future had a similar interface.  I intentionally reused
+the thread interface where possible to lessen the learning
+curve std::lib clients will be faced with.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1049. Response to UK 339
          
+
          Section: 30.6.5 [futures.promise] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [futures.promise].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 339
          
+
+
          
+Move assignment is goiing in the wrong direction, assigning from
+*this to the passed rvalue, and then returning a reference to
+an unusable *this.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+Agree, move to Review.
+
          
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We recommend deferring this issue until after Detlef's paper (on futures)
+has been issued.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Strike 30.6.5 [futures.promise] p6 and change p7:
+
          
+
+
          promise& operator=(promise&& rhs);
+
          
+
          
+
          
+-6- Effects: move assigns its associated state to rhs.
+
          
+
          
+-7- Postcondition: *this has no associated
+state. associated state of *this is the same as the
+associated state of rhs before the call. rhs has no
+associated state.
+
          
+
          
+
          
+
+
+
+
+
+
+
          
+
          1050. Response to UK 340
          
+
          Section: 30.6.5 [futures.promise] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [futures.promise].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 340
          
+
+
          
+There is an implied postcondition for get_future() that the state of the
+promise is transferred into the future leaving the promise with no
+associated state. It should be spelled out.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+Agree, move to Review.
+
          
+
          
+
+
          [
+2009-04-03 Thomas J. Gritzan adds:
+]
          
+
+
+
          
+
          
+promise::get_future() must not invalidate the state of the promise object. 
+
          
+
          
+A promise is used like this: 
+
          
+
          promise<int> p; 
+unique_future<int> f = p.get_future(); 
+// post 'p' to a thread that calculates a value 
+// use 'f' to retrieve the value. 
+
          
+
          
+So get_future() must return an object that shares the same associated 
+state with *this. 
+
          
+
          
+But still, this function should throw an future_already_retrieved error 
+when it is called twice. 
+
          
+
          
+packaged_task::get_future() throws std::bad_function_call if its future
+was already retrieved. It should throw 
+future_error(future_already_retrieved), too. 
+
          
+
          
+Suggested resolution: 
+
          
+
          
+Replace p12/p13 30.6.5 [futures.promise]: 
+
          
+
          
+
          
+-12- Throws: future_error if *this has no associated state
+the future has already been retrieved.
+
          
+
          
+-13- Error conditions: future_already_retrieved if *this
+has no associated state
+the future associated with 
+the associated state has already been retrieved.
+
          
+
          
+Postcondition: The returned object and *this share the associated state.
+
          
+
          
+
          
+Replace p14 30.6.10 [futures.task]: 
+
          
+
          
+
          
+-14- Throws: std::bad_function_call future_error if the future associated with
+the task has already been retrieved.
+
          
+
+
          
+Error conditions: future_already_retrieved if the future associated with 
+the task has already been retrieved. 
+
          
+
          
+Postcondition: The returned object and *this share the associated task.
+
          
+
          
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+Keep in Review status
+pending Detlef's forthcoming paper on futures.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Add after p13 30.6.5 [futures.promise]:
+
          
+
+
          unique_future<R> get_future();
+
          
+
          
+
          
+-13- ...
+
          
+
          
+Postcondition: *this has no associated state.
+
          
+
          
+
          
+
+
+
+
+
+
+
          
+
          1051. Response to UK 279
          
+
          Section: 24.5.1.3.12 [reverse.iter.opindex], 24.5.3.3.12 [move.iter.op.index] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-24
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 279
          
+
+
          
+The reason the return type became unspecified is LWG issue 386. This
+reasoning no longer applies as there are at least two ways to get the right
+return type with the new language facilities added since the previous
+standard. 
+
          
+
+
          
+Proposal: Specify the return type using either decltype or the Iter concept_map.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+Under discussion. This is a general question about all iterator
+adapters.
+
          
+
          
+
+
          [
+Howard adds post Summit:
+]
          
+
+
+
          
+I am requesting test cases to demonstrate a position.
+
          
+
+
          [
+2009-07-24 Daniel adds:
+]
          
+
+
+
          
+
          
+I recommend NAD. Without concepts we can no longer
+restrict this member in a trivial way. Using decltype the
+declaration would be along the lines of
+
          
+
          static const Iter& __base(); // not defined
+auto operator[](difference_type n) const -> decltype(__base()[-n-1]);
+
          
+
+
          
+but once reverse_iterator is instantiated for some given type
+Iter which cannot form a well-formed expression __base()[-n-1]
+this would cause an ill-formed function declaration, diagnostic
+required, and no silent SFINAE elimination.
+
          
+
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Moved to NAD.
+
          
+
+
          [
+2009-10-22 Daniel adds:
+]
          
+
+
+
          
+
          
+IMO, my original comment regarding ill-formedness of the described
+construction is still correct, but I must add that I should weaken my
+assertion "Without concepts we can no longer restrict this member in
+a trivial way".
+
          
+
+
          
+In fact with the existence of default template arguments for function
+templates it is not too hard to implement this like as follows, which
+shows that we can indeed simulate to some sense constrained
+member functions in C++0x.
+
          
+
+
          
+My example does not really proof that the specification is easy, but
+it should be possible. I assume that the implementation would not
+be ABI compatible, though.
+
          
+
+
          
+It is now your own decision how to proceed ;-)
+
          
+
+
          #include <type_traits>
+#include <cstddef>
+
+template<class T>
+typename std::add_rvalue_reference<T>::type declval();
+
+template<class It>
+struct reverse_iterator {
+    It base;
+    
+    typedef std::ptrdiff_t difference_type;
+    
+    template<class U = It, class Res =
+     decltype(declval<const U&>()[declval<difference_type>()])
+    >
+    Res operator[](difference_type n) const  {
+        return base[-n-1];
+    }    
+};
+
+struct MyIter {
+};
+
+int main() {
+    reverse_iterator<int*> ri;
+    ri[0] = 2;
+    reverse_iterator<MyIter> ri2;
+}
+
          
+
+
          
+The above declaration could be simplified, but the ideal solution
+
          
+
+
          template<class U = It>
+  decltype(declval<const U&>()[declval<difference_type>()])
+     operator[](difference_type n) const;
+
          
+
+
          
+does not work yet on gcc 4.4.1.
+
          
+
+
          
+
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1053. Response to UK 295
          
+
          Section: 25 [algorithms] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-23
          
+
          View other active issues in [algorithms].
          
+
          View all other issues in [algorithms].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
+
          Addresses UK 295
          
+
+
          
+There is a level of redundancy in the library specification for many
+algorithms that can be eliminated with the combination of concepts and
+default parameters for function templates. Eliminating redundancy simplified
+specification and reduces the risk of introducing accidental
+inconsistencies.
+
          
+
          
+Proposed resolution: Adopt
+N2743.
+
          
+
+
          [
+Summit:
+]
          
+
+
+
          
+
          
+NAD, this change would break code that takes the address of an
+algorithm.
+
          
+
          
+
+
          [
+Post Summit Alisdair adds:
+]
          
+
+
+
          
+
          
+Request 'Open'.  The issues in the paper go beyond just reducing
+the number of signatures, but cover unifying the idea of the ordering
+operation used by algorithms, containers and other library components.  At
+least, it takes a first pass at the problem.
+
          
+
+
          
+For me (personally) that was the more important part of the paper, and not
+clearly addressed by the Summit resolution.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Too inventive, too late, would really need a paper. Moved to NAD Future.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1054. forward broken
          
+
          Section: 20.3.3 [forward] Status: NAD Editorial
+ Submitter: Howard Hinnant Opened: 2009-03-13  Last modified: 2009-10-26
          
+
          View all other issues in [forward].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          
+This is a placeholder issue to track the fact that we (well I) put the standard
+into an inconsistent state by requesting that we accept
+N2844
+except for the proposed changes to [forward].
+
          
+
+
          
+There will exist in the post meeting mailing
+N2835
+which in its current state reflects the state of affairs prior to the Summit
+meeting.  I hope to update it in time for the post Summit mailing, but as I write
+this issue I have not done so yet.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+Move to Open, awaiting the promised paper.
+
          
+
+
          [
+2009-08-02 Howard adds:
+]
          
+
+
+
          
+
          
+My current preferred solution is:
+
          
+
+
          template <class T>
+struct __base_type
+{
+   typedef typename remove_cv<typename remove_reference<T>::type>::type type;
+};
+
+template <class T, class U,
+   class = typename enable_if<
+       !is_lvalue_reference<T>::value ||
+        is_lvalue_reference<T>::value &&
+        is_lvalue_reference<U>::value>::type,
+   class = typename enable_if<
+        is_same<typename __base_type<T>::type,
+                typename __base_type<U>::type>::value>::type>
+inline
+T&&
+forward(U&& t)
+{
+   return static_cast<T&&>(t);
+}
+
          
+
+
          
+This has been tested by Bill, Jason and myself.
+
          
+
+
          
+It allows the following lvalue/rvalue casts:
+
          
+
+
            
+
          1. 
+Cast an lvalue t to an lvalue T (identity).
+
            2. 
+
          2. 
+Cast an lvalue t to an rvalue T.
+
            3. 
+
          3. 
+Cast an rvalue t to an rvalue T (identity).
+
            4. 
+
          
+
+
          
+It disallows:
+
          
+
+
            
+
          1. 
+Cast an rvalue t to an lvalue T.
+
            2. 
+
          2. 
+Cast one type t to another type T (such as int to double).
+
            3. 
+
          
+
+
          
+"a." is disallowed as it can easily lead to dangling references.
+"b." is disallowed as this function is meant to only change the lvalue/rvalue
+characteristic of an expression.
+
          
+
+
          
+Jason has expressed concern that "b." is not dangerous and is useful in contexts
+where you want to "forward" a derived type as a base type.  I find this use case
+neither dangerous, nor compelling.  I.e. I could live with or without the "b."
+constraint.  Without it, forward would look like:
+
          
+
+
          template <class T, class U,
+   class = typename enable_if<
+       !is_lvalue_reference<T>::value ||
+        is_lvalue_reference<T>::value &&
+        is_lvalue_reference<U>::value>::type>
+inline
+T&&
+forward(U&& t)
+{
+   return static_cast<T&&>(t);
+}
+
          
+
+
          
+Or possibly:
+
          
+
+
          template <class T, class U,
+   class = typename enable_if<
+       !is_lvalue_reference<T>::value ||
+        is_lvalue_reference<T>::value &&
+        is_lvalue_reference<U>::value>::type,
+   class = typename enable_if<
+        is_base_of<typename __base_type<U>::type,
+                   typename __base_type<T>::type>::value>::type>
+inline
+T&&
+forward(U&& t)
+{
+   return static_cast<T&&>(t);
+}
+
          
+
+
+
          
+The "promised paper" is not in the post-Frankfurt mailing only because I'm waiting
+for the non-concepts draft.  But I'm hoping that by adding this information here
+I can keep people up to date.
+
          
+
          
+
+
          [
+2009-08-02 David adds:
+]
          
+
+
+
          
+
          
+forward was originally designed to do one thing: perfect forwarding.
+That is, inside a function template whose actual argument can be a const
+or non-const lvalue or rvalue, restore the original "rvalue-ness" of the
+actual argument:
+
          
+
+
          template <class T>
+void f(T&& x)
+{
+    // x is an lvalue here.  If the actual argument to f was an
+    // rvalue, pass static_cast<T&&>(x) to g; otherwise, pass x.
+    g( forward<T>(x) );
+}
+
          
+
+
          
+Attempting to engineer forward to accomodate uses other than perfect
+forwarding dilutes its idiomatic meaning.  The solution proposed here
+declares that forward<T>(x) means nothing more than static_cast<T&&>(x),
+with a patchwork of restrictions on what T and x can be that can't be
+expressed in simple English.
+
          
+
+
          
+I would be happy with either of two approaches, whose code I hope (but
+can't guarantee) I got right.
+
          
+
+
            
+
          1. 
+
            
+Use a simple definition of forward that accomplishes its original
+purpose without complications to accomodate other uses:
+
            
+
+
            template <class T, class U>
+T&& forward(U& x)
+{
+    return static_cast<T&&>(x);
+}
+
            
+
            2. 
+
+
          2. 
+
            
+Use a definition of forward that protects the user from as many
+potential mistakes as possible, by actively preventing all other
+uses:
+
            
+
+
            template <class T, class U>
+boost::enable_if_c<
+    // in forward<T>(x), x is a parameter of the caller, thus an lvalue
+    is_lvalue_reference<U>::value
+    // in caller's deduced T&& argument, T can only be non-ref or lvalue ref
+    && !is_rvalue_reference<T>::value
+    // Must not cast cv-qualifications or do any type conversions
+    && is_same<T&,U&>::value
+    , T&&>::type forward(U&& a)
+{
+    return static_cast<T&&>(a);
+}
+
            
+
            3. 
+
          
+
+
          
+
+
          [
+2009-09-27 Howard adds:
+]
          
+
+
+
          
+A paper,
+N2951,
+is available which compares several implementations (including David's) with respect to several
+use cases (including Jason's) and provides wording for one implementation.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2951.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1055. Response to UK 98
          
+
          Section: 20.6.7 [meta.trans.other] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-10-26
          
+
          View all other issues in [meta.trans.other].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 98
          
+
+
          
+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.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+Pete observes (and Tom concurs)
+that the proposed resolution seems to require compiler support
+for its implementation,
+as it seems necessary to look at the range of values
+of the enumerated type.
+To a first approximation,
+a library solution could give an answer based on the size of the type.
+If the user has specialized numeric_limits for the enumerated type,
+then the library might be able to do better,
+but there is no such requirement.
+Keep status as Open
+and solicit input from CWG.
+
          
+
+
          [
+2009-05-23 Alisdair adds:
+]
          
+
+
+
          
+Just to confirm that the BSI originator of this comment assumed it did
+indeed imply a compiler intrinsic.  Rather than request a Core extension, it
+seemed in keeping with that the type traits interface provides a library API
+to unspecified compiler features - where we require several other traits
+(e.g. has_trivial_*) to get the 'right' answer now, unlike in TR1.
+
          
+
+
          [
+Addressed in N2947.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2984.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Add a new row to the table in 20.6.7 [meta.trans.other]:
+
          
+
+
          
+
+
+
+
+
+
+
+
+
+
+
+
+
          Table 41 -- Other transformations
          TemplateConditionComments
          
+template< class T > struct enum_base;
+
+T shall be an enumeration type (7.2 [dcl.enum])
+
+The member typedef type shall name the underlying type
+of the enum T.
+
          
+
          
+
+
+
+
+
+
          
+
          1057. RandomNumberEngineAdaptor
          
+
          Section: 26.5 [rand] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-15
          
+
          View all other issues in [rand].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          
+The RandomNumberEngineAdaptor concept breaks precedent in the
+way the library has been specified by grouping requirements into a
+concept that is never actually used in the library.
+
          
+
          
+This is undoubtedly a very helpful device for documentation, but we are not
+comfortable with the precedent - especially as we have rejected national
+body comments on the same grounds.
+
          
+
          
+Suggest either removing the concept, or providing an algorithm/type that
+requires this concept in their definition (such as a factory function to
+create new engines).
+
          
+
          
+The preference is to create a single new algorithm and retain the value of
+the existing documentation.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Walter points out that it is unlikely that any algorithm would ever
+require this concept, but that the concept nonetheless is useful as
+documentation, and (via concept maps) as a means of checking specific adapters.
+
          
+
          
+Alisdair disagrees as to the concept's value as documentation.
+
          
+
          
+Marc points out that the RandomNumberDistribution
+is also a concept not used elsewhere in the Standard.
+
          
+
          
+Pete agrees that a policy of not inventing concepts
+that aren't used in the Standard is a good starting point,
+but should not be used as a criterion for rejecting a concept.
+
          
+
          
+Move to Open.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1058. New container issue
          
+
          Section: 23.2.3 [sequence.reqmts] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-13
          
+
          View other active issues in [sequence.reqmts].
          
+
          View all other issues in [sequence.reqmts].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          
+Sequence containers 23.2.3 [sequence.reqmts]:
+
          
+
+
          
+The return value of new calls added to table 83 are not specified.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We agree with the proposed resolution.
+
          
+
          
+Move to NAD Editorial.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
          
+Add after p6 23.2.3 [sequence.reqmts]:
+
          
+
+
          
+
          
+-6- ...
+
          
+
          
+The iterator returned from a.insert(p,rv) points to the copy of rv
+inserted into a.
+
          
+
          
+The iterator returned from a.emplace(p, args) points to the new
+element constructed from args inserted into a.
+
          
+
          
+
+
+
+
+
+
          
+
          1059. Usage of no longer existing FunctionType concept
          
+
          Section: 20.7.15.2 [func.wrap.func] Status: NAD Concepts
+ Submitter: Daniel Krügler Opened: 2009-03-13  Last modified: 2009-07-16
          
+
          View all other issues in [func.wrap.func].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+Due to a deliberate core language decision, the earlier called
+"foundation" concept std::FunctionType had been removed in
+N2773
+shortly
+before the first "conceptualized" version of the WP
+(N2798)
+had been
+prepared. This caused a break of the library, which already used this
+concept in the adapted definition of std::function
+(20.7 [function.objects]/2, header <functional> synopsis and
+20.7.15.2 [func.wrap.func]).
+
          
+
          
+A simple fix would be to either (a) make std::function's primary template
+unconstrained or to (b) add constraints based on existing (support) concepts.
+A more advanced fix would (c) introduce a new library concept.
+
          
+
          
+The big disadvantage of (a) is, that users can define templates which
+cause compiler errors during instantiation time because of under-constrainedness
+and would thus violate the basic advantage of constrained
+code.
+
          
+
          
+For (b), the ideal constraints for std::function's template parameter would
+be one which excludes everything else but the single provided partial
+specialization that matches every "free function" type (i.e. any function
+type w/o cv-qualifier-seq and w/o ref-qualifier).
+Expressing such a type as as single requirement would be written as
+
          
+
          template<typename T>
+requires ReferentType<T> // Eliminate cv void and function types with cv-qual-seq
+                         //   or ref-qual (depending on core issue #749)
+      && PointeeType<T>  // Eliminate reference types
+      && !ObjectType<T>  // Eliminate object types
+
          
+
          
+Just for completeness approach (c), which would make sense, if the
+library has more reasons to constrain for free function types:
+
          
+
          auto concept FreeFunctionType<typename T>
+  : ReferentType<T>, PointeeType<T>, MemberPointeeType<T>
+{
+  requires !ObjectType<T>;
+}
+
          
+
          
+I mention that approach because I expect that free function types belong
+to the most natural type categories for every days coders. Potential
+candidates in the library are addressof and class template packaged_task.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Alisdair would prefer to have a core-supported FunctionType concept
+in order that any future changes be automatically correct
+without need for a library solution to catch up;
+he points to type traits as a precedent.
+Further, he believes that a published concept can't in the future
+be changed.
+
          
+
          
+Bill feels this category of entity would change sufficiently slowly
+that he would be willing to take the risk.
+
          
+
          
+Of the discussed solutions, we tend toward option (c).
+We like the idea of having a complete taxonomy of native types,
+and perhaps erred in trimming the set.
+
          
+
          
+We would like to have this issue reviewed by Core and would like
+their feedback.  Move to Open.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+Change in 20.7 [function.objects]/2, Header <functional> synopsis:
+
            
+
            // 20.6.16 polymorphic function wrappers:
+class bad_function_call;
+template<FunctionTypeReferentType F>
+requires PointeeType<F> && !ObjectType<F>
+class function; // undefined
+
            
+
            2. 
+
          2. 
+
            
+Change in 20.7.15.2 [func.wrap.func]:
+
            
+
            namespace std {
+template<FunctionTypeReferentType F>
+requires PointeeType<F> && !ObjectType<F>
+class function; // undefined
+
            
+
            3. 
+
          
+
+
+
+
+
+
          
+
          1060. Embedded nulls in NTBS
          
+
          Section: 17.5.2.1.4.1 [byte.strings] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-13  Last modified: 2009-07-13
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          
+Definition of null-terminated sequences allow for embedded nulls. This is
+surprising, and probably not supportable with the intended use cases.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We agree with the issue, but believe this can be handled editorially.
+Move to NAD Editorial.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1061. Bad indexing for tuple access to pair (Editorial?)
          
+
          Section: 20.3.5 [pair.astuple] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-03-13  Last modified: 2009-07-13
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          
+The definition of get implies that get must return the second element if
+given a negative integer.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+Move to NAD Editorial.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+20.3.5 [pair.astuple] p5:
+
          
+
+
          template<int size_t I, class T1, class T2> 
+  requires True<(I < 2)> 
+  const P& get(const pair<T1, T2>&);
+
          
+
          
+
+
+
+
+
+
+
          
+
          1062. Missing insert_iterator for stacks/queues
          
+
          Section: 24.5.2 [insert.iterators] Status: NAD
+ Submitter: Alisdair Meredith Opened: 2009-03-13  Last modified: 2009-10-20
          
+
          View all other issues in [insert.iterators].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          
+It is odd that we have an iterator to insert into a vector, but not an
+iterator to insert into a vector that is adapted as a stack. The standard
+container adapters all have a common interface to push and pop so it should
+be simple to create an iterator adapter to complete the library support.
+
          
+
+
          
+We should provide an AdaptedContainer concept supporting push and pop
+operations. Create a new insert iterator and factory function that inserts
+values into the container by calling push.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Walter recommends NAD Future.
+
          
+
          
+Move to Open, and recommend deferring the issue until after the next
+Committee Draft is issued.
+
          
+
          
+
+
          [
+2009-07-29 Howard moves to Tentatively NAD Future.
+]
          
+
+
+
          
+A poll on the LWG reflector voted unanimously to move this issue to Tentatively NAD Future.
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+Moved to NAD.  The intent of these adapters are to restrict the interfaces.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1063. 03 iterator compatibilty
          
+
          Section: X [iterator.backward] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-15  Last modified: 2009-07-16
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          
+Which header must a user #include to obtain the library-supplied
+concept_maps declared in this paragraph?
+
          
+
+
          
+This is important information, as existing user code will break if this
+header is not included, and we should make a point of mandating this header
+is #include-d by library headers likely to make use of it, notably
+<algorithm>.  See issue 1001 for more details.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We agree with the direction of the proposed resolution.
+Move to Tentatively Ready.
+
          
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+We believe this is NAD Concepts, but this needs to be reviewed against the
+post-remove-concepts draft.
+
          
+
+
+
          Proposed resolution:
          
+
          Change  [depr.lib.iterator.primitives], Iterator primitives, as
+indicated:
          
+
+
          
+  
          To simplify the use of iterators and provide backward compatibility with
+  previous C++ Standard Libraries,
+  the library provides several classes and functions. Unless otherwise
+  specified, these classes and functions shall be defined in header <iterator>.
          
+
          
+
          Change X [iterator.backward], Iterator backward compatibility, as
+indicated:
          
+
          
+  
          The library provides concept maps that allow iterators specified with
+  iterator_traits to interoperate with
+  algorithms that require iterator concepts. These concept maps shall be
+  defined in the same header that defines the iterator. [Example:
          
+
          
+
+
+
+
+
+
          
+
          1064. Response to UK 152
          
+
          Section: 17.3.15 [defns.obj.state] Status: NAD
+ Submitter: Howard Hinnant Opened: 2009-03-15  Last modified: 2009-10-23
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 152
          
+
+
          
+Object state is using a definition of object (instance of a class) from
+outside the standard, rather than the 'region of storage' definiton in
+1.8 [intro.object]p1
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+We think we're removing this; See X [func.referenceclosure.cons].
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD.  This will not affect user or implementer code
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+
          
+
+
+
+
+
+
          
+
          1067. simplified wording for inner_product
          
+
          Section: 26.7 [numeric.ops] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-17  Last modified: 2009-07-14
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          
+One of the motivating examples for introducing requirements-aliases was to
+simplify the wording of the inner_product requirements.  As the paper
+adopting the feature and constrained wording for the library went through in
+the same meeting, it was not possible to make the change at the time.  The
+simpler form should be adopted now though.  Similarly, most the other
+numerical algorithms can benefit from a minor cleanup.
+
          
+
          
+Note that in each case, the second more generalised form of the algorithm
+does not benefit, as there are already named constraints supplied by the
+template type parameters.
+
          
+
+
          [
+2009-05-02 Daniel adds:
+]
          
+
+
+
          
+
          
+one part of the suggested resolution suggests the removal of the
+MoveConstructible<T> requirement from
+inner_product. According to 26.7.2 [inner.product]
+
          
+
+
          
+Computes its result by initializing the accumulator acc with the
+initial value init
+
          
+
+
          
+this step requires at least MoveConstructible.
+
          
+
+
          
+Therefore I strongly suggest to take this removal back (Note also
+that the corresponding overload with a functor argument still has
+the same MoveConstructible<T> requirement).
+
          
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We agree with the proposed resolution as amended by Daniel's suggestion
+to restore MoveConstructible,
+reflected in the updated proposed resolution below.
+
          
+
          
+Move to Tentatively Ready.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change in 26.7 [numeric.ops] and 26.7.1 [accumulate]:
+
          
+
+
          template <InputIterator Iter, MoveConstructible T>
+ requires add = HasPlus<T, Iter::reference>
+       && HasAssign<T, HasPlus<T, Iter::reference> add::result_type>
+ T accumulate(Iter first, Iter last, T init);
+
          
+
+
          
+Change in 26.7 [numeric.ops] and 26.7.2 [inner.product]:
+
          
+
+
          template <InputIterator Iter1, InputIterator Iter2, MoveConstructible T>
+  requires mult = HasMultiply<Iter1::reference, Iter2::reference>
+        && add = HasPlus<T, HasMultiply<Iter1::reference, Iter2::reference> mult::result_type>
+        && HasAssign< 
+             T,
+             HasPlus<T,
+                     HasMultiply<Iter1::reference, Iter2::reference>::result_type> add::result_type>
+  T inner_product(Iter1 first1, Iter1 last1, Iter2 first2, T init);
+
          
+
+
          
+Change in 26.7 [numeric.ops] and 26.7.3 [partial.sum]:
+
          
+
+
          template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
+  requires add = HasPlus<InIter::value_type, InIter::reference>
+        && HasAssign<InIter::value_type,
+                     HasPlus<InIter::value_type, InIter::reference> add::result_type>
+        && Constructible<InIter::value_type, InIter::reference>
+  OutIter partial_sum(InIter first, InIter last, OutIter result);
+
          
+
+
          
+Change in 26.7 [numeric.ops] and 26.7.4 [adjacent.difference]:
+
          
+
+
          template <InputIterator InIter, OutputIterator<auto, const InIter::value_type&> OutIter>
+  requires sub = HasMinus<InIter::value_type, InIter::value_type>
+        && Constructible<InIter::value_type, InIter::reference>
+        && OutputIterator<OutIter, HasMinus<InIter::value_type, InIter::value_type> sub::result_type>
+        && MoveAssignable<InIter::value_type>
+  OutIter adjacent_difference(InIter first, InIter last, OutIter result);
+
          
+
+
+
+
+
+
+
          
+
          1072. Is std::hash a constrained template or not?
          
+
          Section: 20.7.16 [unord.hash] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-19  Last modified: 2009-07-16
          
+
          View other active issues in [unord.hash].
          
+
          View all other issues in [unord.hash].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          
+Is std::hash a constrained template or not?
+
          
+
          
+According to Class template hash 20.7.16 [unord.hash], the definition is:
+
          
+
+
          template <class T>
+struct hash : public std::unary_function<T, std::size_t> {
+  std::size_t operator()(T val) const;
+};
+
          
+
+
          
+And so unconstrained.
+
          
+
          
+According to the <functional> synopsis in p2 Function objects
+20.7 [function.objects] the template is declared as:
+
          
+
+
          template <ReferentType T> struct hash;
+
          
+
+
          
+which would make hash a constrained template.
+
          
+
+
          [
+2009-03-22 Daniel provided wording.
+]
          
+
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Alisdair is not certain that Daniel's proposed resolution is sufficient,
+and recommends we leave the hash template unconstrained for now.
+
          
+
          
+Recommend that the Project Editor make the constrained declaration consistent
+with the definition in order to make the Working Paper internally consistent,
+and that the issue then be revisited.
+
          
+
          
+Move to Open.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
+
          
+[To the editor: This resolution is merge-compatible to the
+resolution of 1078]
+
          
+
+
            
+
          1. 
+
            
+In 20.7 [function.objects]/2, header <functional> synopsis, change as indicated:
+
            
+
+
            // 20.6.17, hash function base template:
+template <ReferentType T> struct hash; // undefined
+
            
+
            2. 
+
          2. 
+
            
+In 20.7.16 [unord.hash]/1 change as indicated:
+
            
+
            namespace std {
+ template <class T>
+ struct hash : public std::unary_function<T, std::size_t> {
+ std::size_t operator()(T val) const;
+ };
+ template <ReferentType T> struct hash; // undefined
+}
+
            
+
            3. 
+
          3. 
+
            
+In 20.7.16 [unord.hash]/2 change as indicated:
+
            
+
+
            
+-2-  For all library-provided specializations, the template
+instantiation hash<T>
+  shall provide a public operator() with return type std::size_t to
+satisfy the concept
+  requirement Callable<const hash<T>, const T&>. If T is an object
+type or reference to
+  object, hash<T> shall be publicly derived from
+std::unary_function<T, std::size_t>.
+   The return value of operator() is unspecified, except that
+equal arguments
+  shall yield the same result. operator() shall not throw exceptions.
+
            
+
            4. 
+
          4. 
+
            
+In 18.7 [support.rtti]/1, header <typeinfo> synopsis change as indicated:
+
            
+
            namespace std {
+  class type_info;
+  class type_index;
+  template <classReferentType T> struct hash;
+
            
+
            5. 
+
          
+
+
+
+
+
+
          
+
          1074. concept map broken by N2840
          
+
          Section: X [allocator.element.concepts] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-03-19  Last modified: 2009-07-13
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          
+p7 Allocator-related element concepts X [allocator.element.concepts]
+
          
+
+
          
+The changes to the AllocatableElement concept mean this concept_map
+specialization no longer matches the original concept:
+
          
+
+
          template <Allocator Alloc, class T, class ... Args>
+  requires HasConstructor<T, Args...>
+    concept_map AllocatableElement<Alloc, T, Args&&...> {
+      void construct_element(Alloc& a, T* t, Args&&... args) {
+        Alloc::rebind<T>(a).construct(t, forward(args)...);
+      }
+    }
+
          
+
+
          [
+2009-03-23 Pablo adds:
+]
          
+
+
+
          
+Actually, this is incorrect,
+N2840
+says. "In section 
+X [allocator.element.concepts] paragraph 8, modify the definition of the
+AllocatableElement concept and eliminate the related concept map:" but
+then neglects to include the red-lined text of the concept map that was
+to be eliminated. Pete also missed this, but I caught it he asked me to
+review his edits.  Pete's updated WP removes the concept map entirely,
+which was the original intent.  The issue is, therefore, moot.  Note, as
+per my presentation of
+N2840
+in summit, construct() no longer has a
+default implementation.  This regrettable fact was deemed (by David
+Abrahams, Doug, and myself) to be preferable to the complexity of
+providing a default implementation that would not under-constrain a more
+restrictive allocator (like the scoped allocators).
+
          
+
+
          [
+2009-05-01 Daniel adds:
+]
          
+
+
          
+
          
+it seems to me that #1074 should be resolved as a NAD, because the
+current WP has already removed the previous AllocatableElement concept map.
+It introduced auto concept AllocatableElement instead, but as of
+X [allocator.element.concepts]/7 this guy contains now
+
          
+
          requires FreeStoreAllocatable<T>;
+void Alloc::construct(T*, Args&&...);
+
          
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+The affected code is no longer part of the Working Draft.
+
          
+
          
+Move to NAD.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change X [allocator.element.concepts]:
+
          
+
+
          template <Allocator Alloc, class T, class ... Args>
+  requires HasConstructor<T, Args...>
+    concept_map AllocatableElement<Alloc, T, Args&&...> {
+      void construct_element(Alloc& a, T* t, Args&&... args) {
+        Alloc::rebind<T>(a).construct(t, forward(args)...);
+      }
+    }
+
          
+
+
+
+
+
+
+
          
+
          1075. Response to US 65, US 74.1
          
+
          Section: 20 [utilities], 23 [containers] Status: NAD Editorial
+ Submitter: Alan Talbot Opened: 2009-03-20  Last modified: 2009-10-26
          
+
          View all other issues in [utilities].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          Addresses US 65 and US 74.1
          
+
+
          US 65:
          
+
+
          
+Scoped allocators and allocator propagation traits add a small amount of
+utility at the cost of a great deal of machinery. The machinery is user
+visible, and it extends to library components that don't have any
+obvious connection to allocators, including basic concepts and simple
+components like pair and tuple.
+
+
          Suggested resolution:
          
+
+
          
+Sketch of proposed resolution: Eliminate scoped allocators, replace
+allocator propagation traits with a simple uniform rule (e.g. always
+propagate on copy and move), remove all mention of allocators from
+components that don't explicitly allocate memory (e.g. pair), and adjust
+container interfaces to reflect this simplification.
+
          
+
          
+Components that I propose eliminating include HasAllocatorType,
+is_scoped_allocator, allocator_propagation_map, scoped_allocator_adaptor,
+and ConstructibleAsElement.
+
          
+
          
+
+
          US 74.1:
          
+
+
          
+
          
+Scoped allocators represent a poor trade-off for standardization, since
+(1) scoped-allocator--aware containers can be implemented outside the
+C++ standard library but used with its algorithms, (2) scoped
+allocators only benefit a tiny proportion of the C++ community
+(since few C++ programmers even use today's allocators), and (3) all C++
+users, especially the vast majority of the C++ community that won't ever
+use scoped allocators are forced to cope with the interface complexity
+introduced by scoped allocators.
+
          
+
          
+In essence, the larger community will suffer to support a very small
+subset of the community who can already implement their own
+data structures outside of the standard library. Therefore, scoped
+allocators should be removed from the working paper.
+
          
+
          
+Some evidence of the complexity introduced by scoped allocators:
+
          
+
          
+
          
+20.3.4 [pairs], 20.5 [tuple]: Large increase in the
+number of pair and tuple constructors.
+
          
+
          
+23 [containers]: Confusing "AllocatableElement" requirements throughout.
+
          
+
          
+
          Suggested resolution:
          
+
+
          
+Remove support for scoped allocators from the working paper. This
+includes at least the following changes:
+
          
+
+
          
+
          
+Remove X [allocator.element.concepts]
+
          
+
          
+Remove 20.8.9 [allocator.adaptor]
+
          
+
          
+Remove 20.8.12 [construct.element]
+
          
+
          
+In Clause 23 [containers]: replace requirements naming the
+AllocatableElement concept with requirements naming CopyConstructible,
+MoveConstructible, DefaultConstructible, or Constructible, as
+appropriate.
+
          
+
          
+
+
          
+
+
          [
+Post Summit Alan moved from NAD to Open.
+]
          
+
+
+
          [
+2009-05-15 Ganesh adds:
+]
          
+
+
+
          
+
          
+The requirement AllocatableElement should not be replaced with
+Constructible on the emplace_xxx() functions as suggested. In the
+one-parameter case the Constructible requirement is not satisfied when
+the constructor is explicit (as per  [concept.map.fct], twelfth
+bullet) but we do want to allow explicit constructors in emplace, as the
+following example shows:
+
          
+
+
          vector<shared_ptr<int>> v;
+v.emplace_back(new int); // should be allowed
+
          
+
+
          
+If the issue is accepted and scoped allocators are removed, I suggest to
+add a new pair of concepts to  [concept.construct], namely:
+
          
+
+
          auto concept HasExplicitConstructor<typename T, typename... Args> {
+ explicit T::T(Args...);
+}
+
+auto concept ExplicitConstructible<typename T, typename... Args>
+ : HasExplicitConstructor<T, Args...>, NothrowDestructible<T>
+{ }
+
          
+
+
          
+We should then use ExplicitConstructible as the requirement for all
+emplace_xxx() member functions.
+
          
+
          
+For coherence and consistency with the similar concepts
+Convertible/ExplicitlyConvertible, we might also consider changing
+Constructible to:
+
          
+
+
          auto concept Constructible<typename T, typename... Args>
+ : HasConstructor<T, Args...>, ExplicitConstructible<T, Args...>
+{ }
+
          
+
+
          
+Moreover, all emplace-related concepts in  [container.concepts]
+should also use ExplicitConstructible instead of Constructible in the
+definitions of their axioms. In fact the concepts in  [container.concepts] should be
+corrected even if the issue is not accepted.
+
          
+
          
+On the other hand, if the issue is not accepted, the scoped allocator
+adaptors should be fixed because the following code:
+
          
+
+
          template <typename T> using scoped_allocator = scoped_allocator_adaptor<allocator<T>>;
+
+vector<shared_ptr<int>, scoped_allocator<shared_ptr<int>>> v;
+v.emplace_back(new int); // ops! doesn't compile
+
          
+
+
          
+doesn't compile, as the member function construct() of the scoped
+allocator requires non-explicit constructors through concept
+ConstructibleWithAllocator. Fixing that is not difficult but probably
+more work than it's worth and is therefore, IMHO, one more reason in
+support of the complete removal of scoped allocators.
+
          
+
          
+
+
          [
+2009-06-09 Alan adds:
+]
          
+
+
+
          
+
          
+I reopened this issue because I did not think that these National Body
+comments were adequately addressed by marking them NAD. My understanding
+is that something can be marked NAD if it is clearly a misunderstanding
+or trivial, but a substantive issue that has any technical merit
+requires a disposition that addresses the concerns.
+
          
+
          
+The notes in the NB comment list (US 65 & US 74.1) say that:
+
          
+
            
+
          1. 
+this issue has not introduced any new arguments not previously discussed,
+
            2. 
+
          2. 
+the vote (4-9-3) was not a consensus for removing scoped allocators,
+
            3. 
+
          3. 
+the issue is resolved by
+N2840.
+
            4. 
+
          
+
          
+My opinion is:
+
          
+
            
+
          1. 
+there are new arguments in both comments regarding concepts (which were
+not present in the library when the scoped allocator proposal was voted
+in),
+
            2. 
+
          2. 
+the vote was clearly not a consensus for removal, but just saying there
+was a vote does not provide a rationale,
+
            3. 
+
          3. 
+I do not believe that N2840 addresses these comments (although it does
+many other things and was voted in with strong approval).
+
            4. 
+
          
+
+
          
+My motivation to open the issue was to ensure that the NB comments were
+adequately addressed in a way that would not risk a "no" vote on our
+FCD. If there are responses to the technical concerns raised, then
+perhaps they should be recorded. If the members of the NB who authored
+the comments are satisfied with N2840 and the other disposition remarks
+in the comment list, then I am sure they will say so. In either case,
+this issue can be closed very quickly in Frankfurt, and hopefully will
+have helped make us more confident of approval with little effort. If in
+fact there is controversy, my thought is that it is better to know now
+rather than later so there is more time to deal with it.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Addressed by
+N2982.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
          Rationale:
          
+Scoped allocators have been revised significantly.
+
+
+
+
+
+
          
+
          1077. Nonesense tuple declarations
          
+
          Section: 20.5.2 [tuple.tuple] Status: NAD Editorial
+ Submitter: Pete Becker Opened: 2009-03-20  Last modified: 2009-07-13
          
+
          View all other issues in [tuple.tuple].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+Class template tuple 20.5.2 [tuple.tuple]:
+
          
+
+
          template <class... UTypes>
+  requires Constructible<Types, const UTypes&>...
+template <class... UTypes>
+  requires Constructible<Types, RvalueOf<UTypes>::type>...
+
          
+
+
          
+Somebody needs to look at this and say what it should be.
+
          
+
+
          [
+2009-03-21 Daniel provided wording.
+]
          
+
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+The resolution looks correct; move to NAD Editorial.
+
          
+
+
+
          Proposed resolution:
          
+
          
+In 20.5.2 [tuple.tuple], class tuple, change as indicated:
+
          
+
+
          template <class... UTypes>
+  requires Constructible<Types, const UTypes&>...
+  tuple(const pair<UTypes...>&);
+template <class... UTypes>
+  requires Constructible<Types, RvalueOf<UTypes>::type>...
+  tuple(pair<UTypes...>&&);
+
          
+
+
          
+[NB.: The corresponding prototypes do already exist in 20.5.2.1 [tuple.cnstr]/7+8]
+
          
+
+
+
+
+
+
          
+
          1078. DE-17: Remove class type_index
          
+
          Section: 20.11 [type.index] Status: NAD Concepts
+ Submitter: Doug Gregor Opened: 2009-03-20  Last modified: 2009-07-16
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses DE 17
          
+
+
          
+DE-17: 
+
          
+
          
+The class type_index should be removed; it provides no additional
+functionality beyond providing appropriate concept maps.
+
          
+
+
          [
+2009-03-31 Peter adds:
+]
          
+
+
+
          
+
          
+It is not true, in principle, that std::type_index provides no  utility
+compared to bare std::type_info*.
+
          
+
          
+std::type_index can avoid the lifetime issues with type_info when  the
+DLL that has produced the type_info object is unloaded. A raw
+type_info* does not, and cannot, provide any protection in this  case.
+A type_index can (if the implementor so chooses) because it  can wrap a
+smart (counted or even cloning) pointer to the type_info  data that is
+needed for name() and before() to work.
+
          
+
          
+
+
+
+
          Proposed resolution:
          
+
          Modify the header <typeinfo> synopsis in 
+  18.7 [support.rtti]p1 as follows:
          
+
+
          namespace std { 
+  class type_info; 
+  class type_index;
+  template <class T> struct hash;
+  template<> struct hash<type_indexconst type_info *> : public std::unary_function<type_indexconst type_info *, size_t> {
+    size_t operator()(type_indexconst type_info * indext) const;
+  };
+  concept_map LessThanComparable<const type_info *> see below
+  class bad_cast; 
+  class bad_typeid;
+}
+
          
+
+
          Add the following new subsection
          
+
          
+
          
+18.7.1.1 Template specialization hash<const type_info *>
+[type.info.hash]
          
+
+
          size_t operator()(const type_info *x) const;
+
          
+
            
+
          1. Returns: x->hash_code()
            2. 
+
          
+
          
+
+ 
          Add the following new subsection
          
+ 
          
+
          18.7.1.2 type_info concept map [type.info.concepts]
          
+
+
+
          concept_map LessThanComparable<const type_info *> {
+  bool operator<(const type_info *x, const type_info *y) { return x->before(*y); }
+  bool operator<=(const type_info *x, const type_info *y) { return !y->before(*x); }
+  bool operator>(const type_info *x, const type_info *y) { return y->before(*x); }
+  bool operator>=(const type_info *x, const type_info *y) { return !x->before(*y); }
+}
+
          
+
            
+  
          1. Note: provides a well-defined ordering among
+  type_info const pointers, which makes such pointers
+  usable in associative containers (23.4).
            2. 
+
          
+
          
+
+
          Remove section 20.11 [type.index]
          
+
+
+
+
+
+
          
+
          1080. Concept ArithmeticLike should provide explicit boolean  conversion
          
+
          Section: X [concept.arithmetic] Status: NAD Concepts
+ Submitter: Daniel Krügler Opened: 2009-03-21  Last modified: 2009-07-15
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+Astonishingly, the current concept ArithmeticLike as specified in
+X [concept.arithmetic] does not provide explicit conversion
+to bool although this is a common property of arithmetic types
+(4.12 [conv.bool]). Recent proposals that introduced such types
+(integers of arbitrary precision,
+n2143,
+decimals
+n2732
+indirectly
+via conversion to long long) also took care of such a feature.
+
          
+
          
+Adding such an explicit conversion associated function would also
+partly solve a currently invalid effects clause in library, which bases
+on this property, 24.2.5 [random.access.iterators]/2:
+
          
+
          { difference_type m = n;
+ if (m >= 0) while (m--) ++r;
+ else while (m++) --r;
+ return r; }
+
          
+
+
          
+Both while-loops take advantage of a contextual conversion to bool
+(Another problem is that the >= comparison uses the no
+longer supported existing implicit conversion from int to IntegralLike).
+
          
+
+Original proposed resolution:
+
            
+
          1. 
+
            
+In X [concept.arithmetic], add to the list of less refined
+concepts one further concept:
+
            
+
+
            concept ArithmeticLike<typename T>
+  : Regular<T>, LessThanComparable<T>, HasUnaryPlus<T>, HasNegate<T>,
+    HasPlus<T, T>, HasMinus<T, T>, HasMultiply<T, T>, HasDivide<T, T>,
+    HasPreincrement<T>, HasPostincrement<T>, HasPredecrement<T>,
+    HasPostdecrement<T>,
+    HasPlusAssign<T, const T&>, HasMinusAssign<T, const T&>,
+    HasMultiplyAssign<T, const T&>,
+    HasDivideAssign<T, const T&>, ExplicitlyConvertible<T, bool> {
+
            
+
            2. 
+
          2. 
+
            
+In 24.2.5 [random.access.iterators]/2 change the current effects clause
+as indicated [The proposed insertion fixes the problem that the previous
+implicit construction from integrals has been changed to an explicit
+constructor]:
+
            
+
            { difference_type m = n;
+ if (m >= difference_type(0)) while (m--) ++r;
+ else while (m++) --r;
+ return r; }
+
            
+
            3. 
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We agree that arithmetic types ought be convertible to bool,
+and we therefore agree with the proposed resolution's paragraph 1.
+
          
+
          
+We do not agree that the cited effects clause is invalid,
+as it expresses intent rather than specific code.
+
          
+
          
+Move to Review, pending input from concepts experts.
+
          
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+In X [concept.arithmetic], add to the list of less refined
+concepts one further concept:
+
          
+
+
          concept ArithmeticLike<typename T>
+  : Regular<T>, LessThanComparable<T>, HasUnaryPlus<T>, HasNegate<T>,
+    HasPlus<T, T>, HasMinus<T, T>, HasMultiply<T, T>, HasDivide<T, T>,
+    HasPreincrement<T>, HasPostincrement<T>, HasPredecrement<T>,
+    HasPostdecrement<T>,
+    HasPlusAssign<T, const T&>, HasMinusAssign<T, const T&>,
+    HasMultiplyAssign<T, const T&>,
+    HasDivideAssign<T, const T&>, ExplicitlyConvertible<T, bool> {
+
          
+
+
+
+
+
+
          
+
          1081. Response to UK 216
          
+
          Section: 21 [strings] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          View all other issues in [strings].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses UK 216, JP 46, JP 48
          
+
+
          
+All the containers use concepts for their iterator usage, exect for
+basic_string. This needs fixing.
+
          
+
+
          
+Use concepts for iterator template parameters throughout the chapter.
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+NB comments to be handled by Dave Abrahams and Howard Hinnant with
+advice from PJP: UK216 (which duplicates) JP46, JP48. JP46 supplies
+extensive proposed wording; start there.
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1082. Response to JP 49
          
+
          Section: 22 [localization] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          View all other issues in [localization].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses JP 49
          
+
+
          
+codecvt does not use concept. For example, create CodeConvert
+concept and change as follows.
+
          
+
+
          template<CodeConvert Codecvt, class Elem = wchar_t>
+  class wstring_convert {
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1083. Response to JP 52, 53
          
+
          Section: 22 [localization] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          View all other issues in [localization].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses JP 52, JP 53
          
+
+
          
+InputIterator does not use concept.
+
          
+
+
          
+OutputIterator does not use concept.
+
          
+
+
          
+Comments include proposed wording.
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+To be handled by Howard Hinnant, Dave Abrahams, Martin Sebor, PJ Plauger.
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1084. Response to UK 250
          
+
          Section: 24.2.3 [forward.iterators] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-16
          
+
          View all other issues in [forward.iterators].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses UK 250
          
+
+
          
+A default implementation should be supplied for the post-increment
+operator to simplify implementation of iterators by users.
+
          
+
+
          
+Copy the Effects clause into the concept description as the default
+implementation. Assumes a default value for postincrement_result
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+Howard will open an issue.
+
          
+
+
          [
+2009-06-07 Daniel adds:
+]
          
+
+
+
          
+This issue cannot currently be resolved as suggested, because
+that would render auto-detection of the return type
+postincrement_result invalid, see  [concept.map.assoc]/4+5. The
+best fix would be to add a default type to that associated type, but
+unfortunately any default type will prevent auto-deduction of types of
+associated functions as quoted above. A corresponding core issue
+is in preparation.
+
          
+
+
+
          Proposed resolution:
          
+
          [
+This wording assumes the acceptance of UK 251 / 1009.  Both
+wordings change the same paragraphs.
+]
          
+
+
+
          
+Change 24.2.3 [forward.iterators]:
+
          
+
+
          
+
          concept ForwardIterator<typename X> : InputIterator<X>, Regular<X> { 
+
+  MoveConstructible postincrement_result;
+  requires HasDereference<postincrement_result>
+        && Convertible<HasDereference<postincrement_result>::result_type, const value_type&>;
+
+  postincrement_result operator++(X& r, int); {
+     X tmp = r;
+     ++r;
+     return tmp;
+  }
+
+  axiom MultiPass(X a, X b) { 
+    if (a == b) *a == *b; 
+    if (a == b) ++a == ++b; 
+  } 
+}
+
          
+
+
+
+
+
+
+
          
+
          1085. Response to UK 258
          
+
          Section: 24.2.4 [bidirectional.iterators] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-16
          
+
          View all other issues in [bidirectional.iterators].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses UK 258
          
+
+
          
+A default implementation should be supplied for the post-decrement
+operator to simplify implementation of iterators by users.
+
          
+
+
          
+Copy the Effects clause into the concept description as the default
+implementation. Assumes a default value for postincrement_result
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+Howard will open an issue.
+
          
+
+
          [
+2009-06-07 Daniel adds:
+]
          
+
+
+
          
+This issue cannot currently be resolved as suggested, because
+that would render auto-detection of the return type
+postdecrement_result invalid, see 1084.
+
          
+
+
+
          Proposed resolution:
          
+
+
          
+Change 24.2.4 [bidirectional.iterators]:
+
          
+
+
          
+
          concept BidirectionalIterator<typename X> : ForwardIterator<X> { 
+  MoveConstructible postdecrement_result; 
+  requires HasDereference<postdecrement_result> 
+        && Convertible<HasDereference<postdecrement_result>::result_type, const value_type&> 
+        && Convertible<postdecrement_result, const X&>; 
+  X& operator--(X&); 
+  postdecrement_result operator--(X& r, int); {
+     X tmp = r;
+     --r;
+     return tmp;
+  }
+}
+
          
+
+
+
+
+
+
+
          
+
          1086. Response to UK 284
          
+
          Section: 24.6 [stream.iterators] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses UK 284
          
+
+
          
+The stream iterators need constraining with concepts/requrires clauses.
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+We agree. To be handled by Howard, Martin and PJ.
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1087. Response to UK 301
          
+
          Section: 25.3.5 [alg.replace] Status: NAD Concepts
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          View all other issues in [alg.replace].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          Addresses UK 301
          
+
+
          
+replace and replace_if have the requirement: OutputIterator<Iter,
+Iter::reference> Which implies they need to copy some values in the
+range the algorithm is iterating over. This is not however the case, the
+only thing that happens is const T&s might be copied over existing
+elements (hence the OutputIterator<Iter, const T&>.
+
          
+
+
          
+Remove OutputIterator<Iter, Iter::reference> from replace
+and replace_if.
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+We agree. To be handled by Howard.
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change in  [algorithms.syn] and 25.3.5 [alg.replace]:
+
          
+
+
          template<ForwardIterator Iter, class T> 
+  requires OutputIterator<Iter, Iter::reference> 
+        && OutputIterator<Iter, const T&> 
+        && HasEqualTo<Iter::value_type, T> 
+  void replace(Iter first, Iter last, 
+               const T& old_value, const T& new_value); 
+
+template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred, class T> 
+  requires OutputIterator<Iter, Iter::reference> 
+        && OutputIterator<Iter, const T&> 
+        && CopyConstructible<Pred> 
+  void replace_if(Iter first, Iter last,
+                  Pred pred, const T& new_value);
+
          
+
+
+
+
+
+
          
+
          1088. Response to UK 342
          
+
          Section: 30.6.5 [futures.promise] Status: NAD Editorial
+ Submitter: Howard Hinnant Opened: 2009-03-22  Last modified: 2009-10-26
          
+
          View all other issues in [futures.promise].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          Addresses UK 342
          
+
+
          
+std::promise is missing a non-member overload of swap. This is
+inconsistent with other types that provide a swap member function.
+
          
+
+
          
+Add a non-member overload void swap(promise&& x,promise&& y){ x.swap(y); }
+
          
+
+
          [
+Summit:
+]
          
+
+
          
+Create an issue. Move to review, attention: Howard. Detlef will also
+look into it.
+
          
+
+
          [
+Post Summit Daniel provided wording.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+In 30.6.5 [futures.promise], before p.1, immediately after class template
+promise add:
+
            
+
            
+template <class R>
+void swap(promise<R>& x, promise<R>& y);
+
+
            
+
            2. 
+
          2. 
+
            
+Change 30.6.5 [futures.promise]/10 as indicated (to fix a circular definition):
+
            
+
            
+
            
+-10- Effects: swap(*this, other)Swaps the associated state
+of *this and other
+
            
+
            
+Throws: Nothing.
+
            
+
            
+
            3. 
+
          3. 
+
            
+After the last paragraph in 30.6.5 [futures.promise] add the following
+prototype description:
+
            
+
            
+template <class R>
+void swap(promise<R>& x, promise<R>& y);
+
            
+
            
+
            
+Effects: x.swap(y)
+
            
+
            
+Throws: Nothing.
+
            
+
            
+
            
+
            4. 
+
+
          
+
+
+
+
+
+
+
          
+
          1091. Multimap description confusing
          
+
          Section: 23.4.2.2 [multimap.modifiers] Status: NAD
+ Submitter: LWG Opened: 2009-03-22  Last modified: 2009-10-20
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 246
          
+
          
+The content of this sub-clause is purely trying to describe in words the
+effect of the requires clauses on these operations, now that we have
+Concepts. As such, the description is more confusing than the signature
+itself. The semantic for these functions is adequately covered in the
+requirements tables in 23.2.4 [associative.reqmts].
+
          
+
+
          [
+Beman adds:
+]
          
+
+
+
          
+Pete is clearly right that
+this one is technical rather than editorial.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We agree with the proposed resolution.
+
          
+
          
+Move to Review.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD, solved by removing concepts.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Strike 23.4.2.2 [multimap.modifiers] entirely
+(but do NOT strike these signatures from the class template definition!).
+
          
+
+
+
+
+
+
          
+
          1092. Class template integral_constant should be a  constrained template
          
+
          Section: 20.6.3 [meta.help] Status: NAD Concepts
+ Submitter: Daniel Krügler Opened: 2009-03-22  Last modified: 2009-07-15
          
+
          View all other issues in [meta.help].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+A first step to change the type traits predicates to constrained templates is to
+constrain their common base template integral_constant. This can be done,
+without enforcing depending classes to be constrained as well, but not
+vice versa
+without brute force late_check usages. The following proposed resolution depends
+on the resolution of LWG issue 1019.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+Move to Open, pending a paper that looks at constraints
+for the entirety of the type traits
+and their relationship to the foundation concepts.
+We recommend this be deferred
+until after the next Committee Draft is issued.
+
          
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+In 20.6.2 [meta.type.synop], Header <type_traits>
+synopsis change as indicated:
+
            
+
            namespace std {
+// 20.5.3, helper class:
+template <classIntegralConstantExpressionType T, T v> struct integral_constant;
+
            
+
            2. 
+
          2. 
+
            
+In 20.6.3 [meta.help] change as indicated:
+
            
+
            template <classIntegralConstantExpressionType T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  typedef T value_type;
+  typedef integral_constant<T,v> type;
+  constexpr operator value_type() { return value; }
+};
+
            
+
            3. 
+
          
+
+
+
+
+
+
          
+
          1096. unconstrained rvalue ref parameters
          
+
          Section: 17 [library] Status: NAD Concepts
+ Submitter: David Abrahams Opened: 2009-03-21  Last modified: 2009-07-16
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+TODO: Look at all cases of unconstrained rvalue ref parameters and check
+that concept req'ts work when T deduced as reference.
+
          
+
+
          
+ We found some instances where that was not done correctly and we figure
+   the possibility of deducing T to be an lvalue reference was probably
+   overlooked elsewhere.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+Move to Open, pending proposed wording from Dave for further review.
+
          
+
+
+
          Proposed resolution:
          
+
          
+
          
+
+
+
+
+
+
          
+
          1101. unique requirements
          
+
          Section: 25.3.9 [alg.unique] Status: NAD Editorial
+ Submitter: Howard Hinnant Opened: 2009-04-25  Last modified: 2009-07-13
          
+
          View all other issues in [alg.unique].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+From Message c++std-core-14160 Howard wrote:
+
          
+
+
          
+It was the intent of the rvalue reference proposal for unique to only require MoveAssignable:
+N1860.
+
          
+
+
          
+And Pete replied:
+
          
+
+
          
+That was overridden by the subsequent changes made for concepts in
+N2573,
+which reimposed the C++03 requirements.
+
          
+
+
          
+My impression is that this overwrite was a simple (unintentional) mistake.
+Wording below to correct it.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Howard notes this issue resolves a discrepancy between the synopsis
+and the description.
+
          
+
          
+Move to NAD Editorial.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change 25.3.9 [alg.unique]:
+
          
+
+
          template<ForwardIterator Iter> 
+  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
+        && EqualityComparable<Iter::value_type> 
+  Iter unique(Iter first, Iter last); 
+
+template<ForwardIterator Iter, EquivalenceRelation<auto, Iter::value_type> Pred> 
+  requires OutputIterator<Iter, RvalueOf<Iter::reference>::type> 
+        && CopyConstructible<Pred> 
+  Iter unique(Iter first, Iter last, Pred pred);
+
          
+
+
          
+Note that the synopsis in  [algorithms.syn] is already correct.
+
          
+
+
+
+
+
+
+
          
+
          1102. std::vector's reallocation policy still unclear
          
+
          Section: 23.3.6.2 [vector.capacity] Status: NAD
+ Submitter: Daniel Krügler Opened: 2009-04-20  Last modified: 2009-10-20
          
+
          View all other issues in [vector.capacity].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
          
+I have the impression that even the wording of current draft
+N2857
+does insufficiently express the intent of vector's
+reallocation strategy. This has produced not too old library
+implementations which release memory in the clear() function
+and even modern articles about C++ programming cultivate
+the belief that clear is allowed to do exactly this. A typical
+example is something like this:
+
          
+
+
          const int buf_size = ...;
+std::vector<T> buf(buf_size);
+for (int i = 0; i < some_condition; ++i) {
+  buf.resize(buf_size);
+  write_or_read_data(buf.data());
+  buf.clear(); // Ensure that the next round get's 'zeroed' elements
+}
+
          
+
          
+where still the myth is ubiquitous that buf might be
+allowed to reallocate it's memory *inside* the for loop.
+
          
+
          
+IMO the problem is due to the fact, that
+
          
+
+
            
+
          1. 
+the actual memory-reallocation stability of std::vector
+is explained in 23.3.6.2 [vector.capacity]/3 and /6 which
+are describing just the effects of the reserve
+function, but in many examples (like above) there
+is no explicit call to reserve involved. Further-more
+23.3.6.2 [vector.capacity]/6 does only mention insertions
+and never mentions the consequences of erasing
+elements.
+
            2. 
+
          2. 
+
            
+the effects clause of std::vector's erase overloads in
+23.3.6.4 [vector.modifiers]/4 is silent about capacity changes. This
+easily causes a misunderstanding, because the counter
+parting insert functions described in 23.3.6.4 [vector.modifiers]/2
+explicitly say, that
+
            
+
            
+Causes reallocation if the new size is greater than the
+old capacity. If no reallocation happens, all the iterators
+and references before the insertion point remain valid.
+
            
+
            
+It requires a complex argumentation chain about four
+different places in the standard to provide the - possibly
+weak - proof that calling clear() also does never change
+the capacity of the std::vector container. Since std::vector
+is the de-facto replacement of C99's dynamic arrays this
+type is near to a built-in type and it's specification should
+be clear enough that usual programmers can trust their
+own reading.
+
            
+
            3. 
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+Bill believes paragraph 1 of the proposed resolution is unnecessary
+because it is already implied (even if tortuously) by the current wording.
+
          
+
          
+Move to Review.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD. Rationale: there is no consensus to clarify the standard,
+general consensus that the standard is correct as written.
+
          
+
+
+
+
          Proposed resolution:
          
+
          [
+This is a minimum version. I also
+suggest that the wording explaining the allocation strategy
+of std::vector in 23.3.6.2 [vector.capacity]/3 and /6 is moved into
+a separate sub paragraph of 23.3.6.2 [vector.capacity] before
+any of the prototype's are discussed, but I cannot provide
+reasonable wording changes now
+]
          
+
+
+
            
+
          1. 
+
            
+Change 23.3.6.2 [vector.capacity]/6 as follows:
+
            
+
            
+It is guaranteed that no reallocation takes place during
+insertions or erasures that happen after a call
+to reserve() until the time when an insertion would make
+the size of the vector greater than the value of capacity().
+
            
+
            2. 
+
          2. 
+
            
+Change 23.3.6.4 [vector.modifiers]/4 as follows:
+
            
+
            
+Effects: The capacity shall remain unchanged and no reallocation shall
+happen.
+Invalidates iterators and references at or after the point
+of the erase.
+
            
+
            3. 
+
          
+
+
+
+
+
+
          
+
          1105. Shouldn't Range be an auto concept
          
+
          Section: X [iterator.concepts.range] Status: NAD Concepts
+ Submitter: David Abrahams Opened: 2009-04-23  Last modified: 2009-07-15
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          [
+2009-04-26 Herb adds:
+]
          
+
+
+
          
+
          
+Here's a common example: We have many ISV customers who have built lots of
+in-house STL-like containers. Imagine that, for the past ten years, the user
+has been happily using his XYZCorpContainer<T> that has begin() and end()
+and an iterator typedef, and indeed satisfies nearly all of Container,
+though maybe not quite all just like valarray. The user upgrades to a
+range-enabled version of a library, and now lib_algo( xyz.begin(), xyz.end());
+no longer works -- compiler error.
+
          
+
          
+Even though XYZCorpContainer matches the pre-conceptized version of the
+algorithm, and has been working for years, it appears the user has to write
+at least this:
+
          
+
          template<class T> concept_map Range<XYZCorpContainer<T>> {};
+
+template<class T> concept_map Range<const XYZCorpContainer<T>> {};
+
          
+
          
+Is that correct?
+
          
+
          
+But he may actually have to write this as we do for initializer list:
+
          
+
          template<class T>
+concept_map Range<XYZCorpContainer<T>> {
+   typedef T* iterator;
+   iterator begin(XYZCorpContainer<T> c) { return c.begin(); }
+   iterator end(XYZCorpContainer<T> c) { return c.end(); }
+};
+
+template<class T>
+concept_map Range<const XYZCorpContainer<T>> {
+   typedef T* iterator;
+   iterator begin(XYZCorpContainer<T> c) { return c.begin(); }
+   iterator end(XYZCorpContainer<T> c) { return c.end(); }
+};
+
          
+
+
          
+
+
          [
+2009-04-28 Alisdair adds:
+]
          
+
+
+
          
+
          
+I recommend NAD, although remain concerned about header organisation.
+
          
+
          
+A user container will satisfy the MemberContainer concept, which IS auto.
+There is a concept_map for all MemberContainers to Container, and then a
+further concept_map for all Container to Range, so the stated problem is not
+actually true.  User defined containers will automatically match the Range
+concept without explicitly declaring a concept_map.
+
          
+
          
+The problem is that they should now provide an additional two headers,
+<iterator_concepts> and <container_concepts>.
+ The only difference from
+making Range an auto concept would be this reduces to a single header,
+<iterator_concepts>.
+
          
+
          
+I am strongly in favour of any resolution that tackles the issue of
+explicitly requiring concept headers to make these concept maps available.
+
          
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We observe there is a recent paper by Bjarne that overlaps this issue.
+
          
+
          
+Alisdair continues to recommend NAD.
+
          
+
          
+Move to Open, and recommend the issue be deferred until after the next
+Committee Draft is issued.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1107. constructor shared_future(unique_future) by value?
          
+
          Section: 30.6.7 [future.shared_future] Status: NAD Editorial
+ Submitter: Thomas J. Gritzan Opened: 2009-04-03  Last modified: 2009-07-13
          
+
          View all other issues in [future.shared_future].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+In the shared_future class definition in 30.6.7 [future.shared_future]
+the move constructor 
+that constructs a shared_future from an unique_future receives the 
+parameter by value. In paragraph 3, the same constructor receives it as 
+const value. 
+
          
+
+
          
+I think that is a mistake and the constructor should take a r-value 
+reference: 
+
          
+
+
          shared_future(unique_future<R>&& rhs);
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We agree with the proposed resolution.
+
          
+
          
+Move to Tentatively Ready.
+
          
+
          
+
+
          [
+2009-07-05 Daniel notes:
+]
          
+
+
+
          
+The proposed change has already been incorported into the current working draft
+N2914.
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change the synopsis in 30.6.7 [future.shared_future]:
+
          
+
+
          shared_future(unique_future<R>&& rhs);
+
          
+
+
          
+Change the definition of the constructor in 30.6.7 [future.shared_future]:
+
          
+
+
          shared_future(const unique_future<R>&& rhs);
+
          
+
+
+
+
+
+
+
          
+
          1109. std::includes should require CopyConstructible predicate
          
+
          Section: 25.4.5.1 [includes] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-04-28  Last modified: 2009-07-13
          
+
          View all other issues in [includes].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+All the set operation algorithms require a CopyConstructible predicate, with
+the exception of std::includes.  This looks like a typo as much as anything,
+given the general library requirement that predicates are copy
+constructible, and wording style of other set-like operations.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+We agree with the proposed resolution.
+Move to NAD Editorial.
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change  [algorithms.syn] and 25.4.5.1 [includes]:
+
          
+
+
          template<InputIterator Iter1, InputIterator Iter2,
+         typename CopyConstructible Compare>
+  requires Predicate<Compare, Iter1::value_type, Iter2::value_type>
+        && Predicate<Compare, Iter2::value_type, Iter1::value_type>
+  bool includes(Iter1 first1, Iter1 last1,
+                Iter2 first2, Iter2 last2,
+                Compare comp);
+
          
+
+
+
+
+
+
          
+
          1111. associative containers underconstrained
          
+
          Section: 23.4 [associative] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-04-29  Last modified: 2009-07-16
          
+
          View all other issues in [associative].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+According to table 87 (n2857) the expression X::key_equal for an unordered
+container shall return a value of type Pred, where Pred is an equivalence
+relation.
+
          
+
+
          
+However, all 4 containers constrain Pred to be merely a Predicate,
+and not EquivalenceRelation.
+
          
+
+
          [
+Batavia (2009-05):
+]
          
+
+
          
+
          
+We agree with the proposed resolution.
+
          
+
          
+Move to Review.
+
          
+
          
+
+
+
          Proposed resolution:
          
+
          
+For ordered containers, replace 
+
          
+
          Predicate<auto, Key, Key> Compare = less<Key>
+
          
+
          
+with 
+
          
+
          StrictWeakOrder<auto, Key, Key> Compare = less<Key>
+
          
+
+
          
+For unordered containers, replace 
+
          
+
          Predicate<auto, Key, Key> Compare = less<Key>
+
          
+
          
+with 
+
          
+
          EquivalenceRelation<auto, Key, Key> Compare = less<Key>
+
          
+
          
+As in the following declarations:
+
          
+
+
          
+
          
+Associative containers 23.4 [associative]
+
          
+
          
+ 1 Headers <map> and <set>:
+
          
+
          
+   Header <map> synopsis
+
          
+
             namespace std {
+     template <ValueType Key, ValueType T,
+               PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+       requires NothrowDestructible<Key> && NothrowDestructible<T>
+             && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class map;
+
+     ...
+
+     template <ValueType Key, ValueType T,
+               PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+       requires NothrowDestructible<Key> && NothrowDestructible<T>
+             && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class multimap;
+
+     ...
+
+   }
+
          
+
+
          
+   Header <set> synopsis
+
          
+
             namespace std {
+     template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<Key> >
+       requires NothrowDestructible<Key> && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class set;
+
+     ...
+
+     template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+               Allocator Alloc = allocator<Key> >
+       requires NothrowDestructible<Key> && CopyConstructible<Compare>
+             && AllocatableElement<Alloc, Compare, const Compare&>
+             && AllocatableElement<Alloc, Compare, Compare&&>
+     class multiset;
+
+     ...
+
+   }
+
          
+
+
          
+ 23.4.1p2 Class template map [map]
+
          
+
           namespace std {
+   template <ValueType Key, ValueType T,
+             PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class map {
+     ...
+   };
+ }
+
          
+
+
+
          
+ 23.4.2p2 Class template multimap [multimap]
+
          
+
           namespace std {
+   template <ValueType Key, ValueType T,
+             PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class multimap {
+     ...
+   };
+ }
+
          
+
+
+
          
+ 23.4.3p2 Class template set [set]
+
          
+
           namespace std {
+   template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<Key> >
+     requires NothrowDestructible<Key> && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class set {
+     ...
+   };
+ }
+
          
+
+
+
          
+ 23.4.4p2 Class template multiset [multiset]
+
          
+
           namespace std {
+   template <ValueType Key, PredicateStrictWeakOrder<auto, Key, Key> Compare = less<Key>,
+             Allocator Alloc = allocator<Key> >
+     requires NothrowDestructible<Key> && CopyConstructible<Compare>
+           && AllocatableElement<Alloc, Compare, const Compare&>
+           && AllocatableElement<Alloc, Compare, Compare&&>
+   class multiset {
+     ...
+   };
+ }
+
          
+
+
          
+ 23.5 Unordered associative containers [unord]
+
          
+
          
+ 1 Headers <unordered_map> and <unordered_set>:
+
          
+
          
+ Header <unordered_map> synopsis
+
          
+
           namespace std {
+   // 23.5.1, class template unordered_map:
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_map;
+
+   // 23.5.2, class template unordered_multimap:
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_multimap;
+
+   ...
+ }
+
          
+
+
          
+ Header <unordered_set> synopsis
+
          
+
           namespace std {
+   // 23.5.3, class template unordered_set:
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_set;
+
+   // 23.5.4, class template unordered_multiset:
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+     class unordered_multiset;
+
+   ...
+ }
+
          
+
+
          
+ 23.5.1p3 Class template unordered_map [unord.map]
+
          
+
           namespace std {
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_map
+   {
+     ...
+   };
+ }
+
          
+
+
          
+ 23.5.2p3 Class template unordered_multimap [unord.multimap]
+
          
+
           namespace std {
+   template <ValueType Key,
+             ValueType T,
+             Callable<auto, const Key&> Hash = hash<Key>,
+             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
+             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
+     requires NothrowDestructible<Key> && NothrowDestructible<T>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_multimap
+   {
+     ...
+   };
+ }
+
          
+
+
          
+ 23.5.3p3 Class template unordered_set [unord.set]
+
          
+
           namespace std {
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_set
+   {
+     ...
+   };
+ }
+
          
+
          
+ 23.5.4p3 Class template unordered_multiset [unord.multiset]
+
          
+
           namespace std {
+   template <ValueType Value,
+             Callable<auto, const Value&> Hash = hash<Value>,
+             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
+             Allocator Alloc = allocator<Value> >
+     requires NothrowDestructible<Value>
+           && SameType<Hash::result_type, size_t>
+           && CopyConstructible<Hash> && CopyConstructible<Pred>
+           && AllocatableElement<Alloc, Pred, const Pred&>
+           && AllocatableElement<Alloc, Pred, Pred&&>
+           && AllocatableElement<Alloc, Hash, const Hash&>
+           && AllocatableElement<Alloc, Hash, Hash&&>
+   class unordered_multiset
+   {
+     ...
+   };
+ }
+
          
+
+
          
+
+
+
+
+
+
+
          
+
          1116. Literal constructors for tuple
          
+
          Section: 20.5.2 [tuple.tuple] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-10-26
          
+
          View all other issues in [tuple.tuple].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+It is not currently possible to construct tuple literal values,
+even if the elements are all literal types.  This is because parameters
+are passed to constructor by reference.
+
          
+
          
+An alternative would be to pass all constructor arguments by value, where it
+is known that *all* elements are literal types.  This can be determined with
+concepts, although note that the negative constraint really requires
+factoring out a separate concept, as there is no way to provide an 'any of
+these fails' constraint inline.
+
          
+
          
+Note that we will have similar issues with pair (and
+tuple constructors from pair) although I am steering
+clear of that class while other constructor-related issues settle.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2994.
+
          
+
+
+
          Proposed resolution:
          
+
          
+Ammend the tuple class template declaration in 20.5.2 [tuple.tuple] as
+follows
+
          
+
+
          
+
          
+Add the following concept:
+
          
+
+
          auto concept AllLiteral< typename ... Types > {
+  requires LiteralType<Types>...;
+}
+
          
+
+
          
+ammend the constructor 
+
          
+
+
          template <class... UTypes>
+  requires AllLiteral<Types...>
+        && Constructible<Types, UTypes>...
+  explicit tuple(UTypes...);
+
+template <class... UTypes>
+  requires !AllLiteral<Types...>
+        && Constructible<Types, UTypes&&>...
+  explicit tuple(UTypes&&...);
+
          
+
+
          
+ammend the constructor
+
          
+
+
          template <class... UTypes>
+  requires AllLiteral<Types...>
+        && Constructible<Types, UTypes>...
+  tuple(tuple<UTypes...>);
+
+template <class... UTypes>
+  requires !AllLiteral<Types...>
+        && Constructible<Types, const UTypes&>...
+  tuple(const tuple<UTypes...>&);
+
          
+
+
          
+
+
          
+Update the same signatures in 20.5.2.1 [tuple.cnstr], paras 3 and 5.
+
          
+
+
+
+
+
+
          
+
          1117. tuple copy constructor
          
+
          Section: 20.5.2.1 [tuple.cnstr] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-10-26
          
+
          View all other issues in [tuple.cnstr].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+The copy constructor for the tuple template is constrained.  This seems an
+unusual strategy, as the copy constructor will be implicitly deleted if the
+constraints are not met.  This is exactly the same effect as requesting an
+=default; constructor.  The advantage of the latter is that it retains
+triviality, and provides support for tuples as literal types if issue
+1116 is also accepted.
+
          
+
          
+Actually, it might be worth checking with core if a constrained copy
+constructor is treated as a constructor template, and as such does not
+suppress the implicit generation of the copy constructor which would hide
+the template in this case.
+
          
+
+
          [
+2009-05-27 Daniel adds:
+]
          
+
+
+
          
+This would solve one half of the suggested changes in 801.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2994.
+
          
+
+
+
          Proposed resolution:
          
+
          
+Change 20.5.2 [tuple.tuple] and 20.5.2.1 [tuple.cnstr] p4:
+
          
+
+
          requires CopyConstructible<Types>... tuple(const tuple&) = default;
+
          
+
+
+
+
+
+
          
+
          1120. New type trait - remove_all
          
+
          Section: 20.6 [meta] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-05-23  Last modified: 2009-10-26
          
+
          View all other issues in [meta].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
          
+Sometimes it is necessary to remove all qualifiers from a type before
+passing on to a further API.  A good example would be calling the
+tuple query APIs tuple_size or tuple_element
+with a deduced type inside a function template.  If the deduced type is
+cv-qualified or a reference then the call will fail.  The solution is to
+chain calls to
+remove_cv<remove_reference<T>::type>::type, and
+note that the order matters.
+
          
+
          
+Suggest it would be helpful to add a new type trait,
+remove_all, that removes all top-level qualifiers from a type
+i.e. cv-qualification and any references.  Define the term in such a way
+that if additional qualifiers are added to the language, then
+remove_all is defined as stripping those as well.
+
          
+
+
          [
+2009-10-14 Daniel adds:
+]
          
+
+
+
          
+remove_all seems too generic, a possible alternative matching
+the current naming style could be remove_cv_reference or
+remove_reference_cv. It should also be considered whether this
+trait should also remove 'extents', or pointer 'decorations'. Especially
+if the latter situations are considered as well, it might be easier to
+chose the name not in terms of what it removes (which might be
+a lot), but in terms of it creates. In this case I could think
+of e.g. extract_value_type.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Future.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1122. Ratio values should be constexpr
          
+
          Section: 20.4.1 [ratio.ratio] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-05-25  Last modified: 2009-10-26
          
+
          View all other issues in [ratio.ratio].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+The values num and den in the ratio template
+should be declared constexpr.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2994.
+
          
+
+
+
          Proposed resolution:
          
+
          
+20.4.1 [ratio.ratio]
+
          
+
+
          namespace std {
+  template <intmax_t N, intmax_t D = 1>
+  class ratio {
+  public:
+    static constexpr intmax_t num;
+    static constexpr intmax_t den;
+  };
+}
+
          
+
+
+
+
+
+
+
          
+
          1124.  Invalid definition of concept RvalueOf
          
+
          Section: X [concept.transform] Status: NAD Concepts
+ Submitter: Daniel Krügler Opened: 2009-05-28  Last modified: 2009-07-15
          
+
          View all other issues in [concept.transform].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+A recent news group
+article
+points to several defects in the
+specification of reference-related concepts.
+
          
+
          
+One problem of the concept RvalueOf as currently defined in
+X [concept.transform]:
+
          
+
+
          concept RvalueOf<typename T> {
+ typename type = T&&;
+ requires ExplicitlyConvertible<T&,type> && Convertible<T&&,type>;
+}
+
+template<typename T> concept_map RvalueOf<T&> {
+ typedef T&& type;
+}
+
          
+
+
          
+is that if T is an lvalue-reference, the requirement
+Convertible<T&&,type> isn't satisfied for
+lvalue-references, because after reference-collapsing in the concept
+definition we have Convertible<T&,type> in this case,
+which isn't satisfied in the concept map template and also is not the
+right constraint either. I think that the reporter is right that
+SameType requirements should do the job and that we also should
+use the new RvalueReference concept to specify a best matching
+type requirement.
+
          
+
+
+
          Proposed resolution:
          
+
          
+In X [concept.transform] before p. 4 change as indicated:
+
          
+
+
          auto concept RvalueOf<typename T> {
+  typenameRvalueReference type = T&&;
+  requires ExplicitlyConvertible<T&, type> && Convertible<T&&, type>SameType<T&, type&>;
+}
+
          
+
+
+
+
+
+
          
+
          1127. rvalue references and iterator traits
          
+
          Section: 24.4.1 [iterator.traits] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-07-15
          
+
          View all other issues in [iterator.traits].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+The deprecated support for iterator_traits and legacy (unconstrained)
+iterators features the (exposition only) concept:
+
          
+
+
          concept IsReference<typename T> { } // exposition only
+template<typename T> concept_map IsReference<T&> { }
+
          
+
          
+Now this looks exactly like the LvalueReference concept recently added to
+clause 20, so I wonder if we should use that instead?
+Then I consider the lack of rvalue-reference support, which means that
+move_iterator would always flag as merely supporting the input_iterator_tag
+category.  This suggests we retain the exposition concept, but add a second
+concept_map to support rvalue references.
+
          
+
          
+I would suggest adding the extra concept_map is the right way forward, but
+still wonder if the two exposition-only concepts in this clause might be
+worth promoting to clause 20.  That question might better be answered with a
+fuller investigation of type_trait/concept unification though.
+
          
+
+
+
          Proposed resolution:
          
+
          
+In Iterator traits 24.4.1 [iterator.traits] para 4 add:
+
          
+
+
          concept IsReference<typename T> { } // exposition only
+template<typename T> concept_map IsReference<T&> { }
+template<typename T> concept_map IsReference<T&&> { }
+
          
+
+
+
+
+
+
+
          
+
          1128. Missing definition of iterator_traits<T*>
          
+
          Section: X [iterator.syn] Status: NAD Concepts
+ Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-07-16
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+The <iterator> header synopsis declares a partial specialization of
+iterator_traits to support pointers, X [iterator.syn].  The implication
+is that specialization will be described in D10, yet it did not follow the
+rest of the deprecated material into this clause.
+
          
+
          
+However, this is not as bad as it first seems!
+There are partial specializations of iterator_traits for types that satisfy
+the various Iterator concepts, and there are concept_maps for pointers to
+explicitly support the RandomAccessIterator concept, so the required
+template will be present - just not in the manner advertised.
+
          
+
          
+I can see two obvious solutions:
+
          
+
+
            
+
          1. 
+Restore the iterator_traits<T*> partial specialization in D.10
+
            2. 
+
          2. 
+Remove the declaration of iterator_traits<T*> from 24.3 synopsis
+
            3. 
+
          
+
          
+I recommend option (ii) in the wording below
+
          
+
          
+Option (ii) could be extended to strike all the declarations of deprecated
+material from the synopsis, as it is effectively duplicating D.10 anyway.
+This is the approach taken for deprecated library components in the 98/03
+standards.  This is probably a matter best left to the Editor though.
+
          
+
+
+
          Proposed resolution:
          
+
          
+In X [iterator.syn] strike:
+
          
+
+
          template<class T> struct iterator_traits<T*>;
+
          
+
+
+
+
+
+
+
          
+
          1129. istream(buf)_iterator should support literal sentinel value
          
+
          Section: 24.6.1.1 [istream.iterator.cons], 24.6.3 [istreambuf.iterator] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-05-30  Last modified: 2009-10-26
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+istream_iterator and istreambuf_iterator should support literal sentinel
+values.  The default constructor is frequently used to terminate ranges, and
+could easily be a literal value for istreambuf_iterator, and
+istream_iterator when iterating value types.  A little more work using a
+suitably sized/aligned char-array for storage (or an updated component like
+boost::optional proposed for TR2) would allow istream_iterator to support
+constexpr default constructor in all cases, although we might leave this
+tweak as a QoI issue.  Note that requiring constexpr be supported also
+allows us to place no-throw guarantees on this constructor too.
+
          
+
+
          [
+2009-06-02 Daniel adds:
+]
          
+
+
+
          
+
          
+I agree with the usefulness of the issue suggestion, but we need
+to ensure that istream_iterator can satisfy be literal if needed.
+Currently this is not clear, because 24.6.1 [istream.iterator]/3 declares
+a copy constructor and a destructor and explains their semantic in
+24.6.1.1 [istream.iterator.cons]/3+4.
+
          
+
          
+The prototype semantic specification is ok (although it seems
+somewhat redundant to me, because the semantic doesn't say
+anything interesting in both cases), but for support of trivial class
+types we also need a trivial copy constructor and destructor as of
+9 [class]/6. The current non-informative specification of these
+two special members suggests to remove their explicit declaration
+in the class and add explicit wording that says that if T is
+trivial a default constructed iterator is also literal, alternatively it
+would be possible to mark both as defaulted and add explicit
+(memberwise) wording that guarantees that they are trivial.
+
          
+
          
+Btw.: I'm quite sure that the istreambuf_iterator additions to
+ensure triviality are not sufficient as suggested, because the
+library does not yet give general guarantees that a defaulted
+special member declaration makes this member also trivial.
+Note that e.g. the atomic types do give a general statement!
+
          
+
          
+Finally there is a wording issue: There does not exist something
+like a "literal constructor". The core language uses the term
+"constexpr constructor" for this.
+
          
+
          
+Suggestion:
+
          
+
            
+
          1. 
+
            
+Change 24.6.1 [istream.iterator]/3 as indicated:
+
            
+
            constexpr istream_iterator();
+istream_iterator(istream_type& s);
+istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
+~istream_iterator() = default;
+
            
+
            2. 
+
          2. 
+
            
+Change 24.6.1.1 [istream.iterator.cons]/1 as indicated:
+
            
+
            constexpr istream_iterator();
+
            
+
            
+-1- Effects: Constructs the end-of-stream iterator. If T is a literal type,
+then this constructor shall be a constexpr constructor.
+
            
+
            
+
            3. 
+
          3. 
+
            
+Change 24.6.1.1 [istream.iterator.cons]/3 as indicated:
+
            
+
            istream_iterator(const istream_iterator<T,charT,traits,Distance>& x) = default;
+
            
+
            
+-3- Effects: Constructs a copy of x. If T is a literal type, then
+this constructor shall be a trivial copy constructor.
+
            
+
            
+
            4. 
+
          4. 
+
            
+Change 24.6.1.1 [istream.iterator.cons]/4 as indicated:
+
            
+
+
            ~istream_iterator() = default;
+
            
+
            
+-4- Effects: The iterator is destroyed. If T is a literal type, then
+this destructor shall be a trivial
+destructor.
+
            
+
            
+
            5. 
+
          5. 
+
            
+Change 24.6.3 [istreambuf.iterator] before p. 1 as indicated:
+
            
+
+
            constexpr istreambuf_iterator() throw();
+istreambuf_iterator(const istreambuf_iterator&)  throw() = default;
+~istreambuf_iterator()  throw() = default;
+
            
+
            6. 
+
          6. 
+
            
+Change 24.6.3 [istreambuf.iterator]/1 as indicated:
+
            
+
            
+[..] The default constructor istreambuf_iterator() and the constructor
+istreambuf_iterator(0) both
+construct an end of stream iterator object suitable for use as an
+end-of-range. All
+specializations of istreambuf_iterator shall have a trivial copy
+constructor, a constexpr default
+constructor and a trivial destructor.
+
            
+
            7. 
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2994.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+24.6.1 [istream.iterator] para 3
+
          
+
+
          constexpr istream_iterator();
+
          
+
+
          
+24.6.1.1 [istream.iterator.cons]
+
          
+
+
          constexpr istream_iterator();
+
          
+
          
+-1- Effects: Constructs the end-of-stream iterator.
+If T is a literal type, then this constructor shall
+be a literal constructor.
+
          
+
          
+
+
          
+24.6.3 [istreambuf.iterator]
+
          
+
+
          constexpr istreambuf_iterator() throw();
+
          
+
+
+
+
+
+
+
          
+
          1132. JP-30: nested exceptions
          
+
          Section: 18.8.6 [except.nested] Status: NAD
+ Submitter: Seiji Hayashida Opened: 2009-06-01  Last modified: 2009-10-23
          
+
          View other active issues in [except.nested].
          
+
          View all other issues in [except.nested].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
          Addresses JP 30
          
+
+
          
+C++0x nested_exception cannot handle a structured exception well. The
+following codes show two types of tree structured exception handling.
+
          
+
          
+The first one is based on nested_exception in C++0x,
+while the second one is based on my library trickerr.h (in Japanese).
+http://tricklib.com/cxx/dagger/trickerr.h
+
          
+
          
+Assume that Function A() calls two sub functions A_a() and A_b(), both might
+throw tree structured exceptions, and A_b() must be called even if A_a()
+throws an exception.
+
          
+
          
+List A (code of tree structured exception handling based on nested_exception
+in C++0x)
+
          
+
+
          void A()
+{
+    try
+    {
+        std::vector<exception_ptr> exception_list;
+        try
+        {
+            // A_a() does a similar processing as A().
+            A_a();
+        }
+        catch(...)
+        {
+            exception_list.push_back(current_exception());
+        }
+
+        // ***The processing A() has to do even when A_a() fails. ***
+        try
+        {
+            // A_b() does a similar processing as A().
+            A_b();
+        }
+        catch(...)
+        {
+            exception_list.push_back(current_exception());
+        }
+        if (!exception_list.empty())
+        {
+            throw exception_list;
+        }
+    }
+    catch(...)
+    {
+        throw_with_nested(A_exception("someone error"));
+    }
+}
+void print_tree_exception(exception_ptr e, const std::string & indent ="")
+{
+    const char * indent_unit = " ";
+    const char * mark = "- ";
+    try
+    {
+        rethow_exception(e);
+    }
+    catch(const std::vector<exception_ptr> e)
+    {
+        for(std::vector<exception_ptr>::const_iterator i = e.begin(); i!=e.end(); ++i)
+        {
+            print_tree_exception(i, indent);
+        }
+    }
+    catch(const std::nested_exception  e)
+    {
+        print_tree_exception(evil_i(e), indent +indent_unit);
+    }
+    catch(const std::exception e)
+    {
+        std::cout << indent << mark << e.what() << std::endl;
+    }
+    catch(...)
+    {
+        std::cout << indent << mark << "unknown exception" << std::endl;
+    }
+}
+int main(int, char * [])
+{
+    try
+    {
+        A();
+    }
+    catch()
+    {
+        print_tree_exception(current_exception());
+    }
+    return EXIT_SUCCESS;
+}
+
          
+
+
          
+List B ( code of tree structured exception handling based on trickerr.h. )
+"trickerr.h" (in Japanese), refer to:
+http://tricklib.com/cxx/dagger/trickerr.h.
+
          
+
+
          void A()
+{
+    tricklib::error_listener_type error_listener;
+    // A_a() is like A(). A_a() can throw tree structured exception.
+    A_a();
+
+    // *** It must do process so that A_a() throws exception in A(). ***
+    // A_b() is like A(). A_b() can throw tree structured exception.
+    A_b();
+
+    if (error_listener.has_error()) // You can write this "if block" in destructor
+                                    //  of class derived from error_listener_type.
+    {
+        throw_error(new A_error("someone error",error_listener.listener_off().extract_pending_error()));
+    }
+}
+void print_tree_error(const tricklib::error_type &a_error, const std::string & indent = "")
+{
+    const char * indent_unit = " ";
+    const char * mark = "- ";
+
+    tricklib::error_type error = a_error;
+    while(error)
+    {
+        std::cout << indent << mark << error->message << std::endl;
+        if (error->children)
+        {
+            print_tree_error(error->children, indent +indent_unit);
+        }
+        error = error->next;
+    }
+}
+int main(int, char * [])
+{
+    tricklib::error_thread_power error_thread_power_on; // This object is necessary per thread.
+
+    try
+    {
+        A();
+    }
+    catch(error_type error)
+    {
+        print_tree_error(error);
+    }
+    catch(...)
+    {
+        std::cout << "- unknown exception" << std::endl;
+    }
+    return EXIT_SUCCESS;
+}
+
          
+
+
          
+Prospect
+
          
+
          
+We will focus on the method A() since the other methods, also main(), occur
+only once respectively.
+
          
+
+
            
+
          • 
+ In the List A above (of the nested exception handling), it is hard to
+ find out an active reason to use the nested exception handling at this
+ scene. Rather, we can take a simpler description by throwing the entire
+ exception_list directly to the top level.
+
            • 
+
          • 
+ The code in the same example gives us a kind of redundant impression,
+ which might have come from the fact that the try-throw-catch framework does
+ not assume a tree structured exception handling.
+
            • 
+
          
+
+
          
+According to the above observation, we cannot help concluding that it is not
+so easy to use the nested_exception handling as a tree structured exception
+handling mechanism in a practical sense.
+
          
+
          
+This text is based on the web page below (in Japanese).
+http://d.hatena.ne.jp/wraith13/20081231/1230715424
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark as NAD. The committee agrees that nested_exception is not a good
+match for this usage model. The committee did not see a way of improving
+this within the timeframe allowed.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+
          
+
+
+
+
+
+
          
+
          1139. Thread support library not concept enabled
          
+
          Section: 30 [thread] Status: NAD Concepts
+ Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
+
          View all other issues in [thread].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses US 93, JP 79, UK 333, JP 81
          
+
+
          
+The thread chapter is not concept enabled.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1140. Numerics library not concept enabled
          
+
          Section: 26 [numerics] Status: NAD Concepts
+ Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
+
          View all other issues in [numerics].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses US 84
          
+
+
          
+The numerics chapter is not concept enabled.
+
          
+
+
          
+The portion of this comment dealing with random numbers was resolved by
+N2836,
+which was accepted in Summit.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1141. Input/Output library not concept enabled
          
+
          Section: 27 [input.output] Status: NAD Concepts
+ Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
+
          View all other issues in [input.output].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses US 85, JP 67, JP 68, JP 69, JP 72, UK 308
          
+
+
          
+The input/output chapter is not concept enabled.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1142. Regular expressions library not concept enabled
          
+
          Section: 28 [re] Status: NAD Concepts
+ Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
+
          View all other issues in [re].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
+
          Addresses US 86, UK 309, UK 310
          
+
+
          
+The regular expressions chapter is not concept enabled.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1143. Atomic operations library not concept enabled
          
+
          Section: 29 [atomics] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-15  Last modified: 2009-10-26
          
+
          View all other issues in [atomics].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses US 87, UK 311
          
+
+
          
+The atomics chapter is not concept enabled.
+
          
+
+
          
+Needs to also consider issues 923 and 924.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2992.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1145. inappropriate headers for atomics
          
+
          Section: 29 [atomics] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-16  Last modified: 2009-10-26
          
+
          View all other issues in [atomics].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 312
          
+
+
          
+The contents of the <stdatomic.h> header are not listed anywhere,
+and <cstdatomic> is listed as a C99 header in chapter 17.
+If we intend to use these for compatibility with a future C standard,
+we should not use them now.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2992.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Remove <cstdatomic> from the C99 headers in table 14.
+Add a new header <atomic> to the headers in table 13.
+Update chapter 29 to remove reference to <stdatomic.h>
+and replace the use of <cstdatomic> with <atomic>.
+
          
+
          [
+If and when WG14 adds atomic operations to C
+we can add corresponding headers to table 14 with a TR.
+]
          
+
+
+
+
+
+
+
          
+
          1146. "lockfree" does not say enough
          
+
          Section: 29.4 [atomics.lockfree] Status: NAD Editorial
+ Submitter: Jeffrey Yasskin Opened: 2009-06-16  Last modified: 2009-10-26
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses US 88
          
+
+
          
+The "lockfree" facilities do not tell the programmer enough.
+
          
+
+
          
+There are 2 problems here.
+First, at least on x86,
+it's less important to me whether some integral types are lock free
+than what is the largest type I can pass to atomic and have it be lock-free.
+For example, if long longs are not lock-free,
+ATOMIC_INTEGRAL_LOCK_FREE is probably 1,
+but I'd still be interested in knowing whether longs are always lock-free.
+Or if long longs at any address are lock-free,
+I'd expect ATOMIC_INTEGRAL_LOCK_FREE to be 2,
+but I may actually care whether I have access to
+the cmpxchg16b instruction.
+None of the support here helps with that question.
+(There are really 2 related questions here:
+what alignment requirements are there for lock-free access;
+and what processor is the program actually running on,
+as opposed to what it was compiled for?)
+
          
+
+
          
+Second, having atomic_is_lock_free only apply to individual objects
+is pretty useless
+(except, as Lawrence Crowl points out,
+for throwing an exception when an object is unexpectedly not lock-free).
+I'm likely to want to use its result to decide what algorithm to use,
+and that algorithm is probably going to allocate new memory
+containing atomic objects and then try to act on them.
+If I can't predict the lock-freedom of the new object
+by checking the lock-freedom of an existing object,
+I may discover after starting the algorithm that I can't continue.
+
          
+
+
          [
+2009-06-16 Jeffrey Yasskin adds:
+]
          
+
+
+
          
+
          
+To solve the first problem, I think 2 macros would help:
+MAX_POSSIBLE_LOCK_FREE_SIZE and MAX_GUARANTEED_LOCK_FREE_SIZE,
+which expand to the maximum value of sizeof(T) for which atomic may
+(or will, respectively) use lock-free operations.
+Lawrence points out that this
+"relies heavily on implementations
+using word-size compare-swap on sub-word-size types,
+which in turn requires address modulation."
+He expects that to be the end state anyway, so it doesn't bother him much.
+
          
+
+
          
+To solve the second,
+I think one could specify that equally aligned objects of the same type
+will return the same value from atomic_is_lock_free().
+I don't know how to specify "equal alignment".
+Lawrence suggests an additional function, atomic_is_always_lock_free().
+
          
+
          
+
+
          [
+2009-10-22 Benjamin Kosnik:
+]
          
+
+
+
          
+
          
+In the evolution discussion of N2925, "More Collected Issues with
+Atomics," there is an action item with respect to
+LWG 1146, US 88
+
          
+
+
          
+This is stated in the paper as:
+
          
+
          
+Relatedly, Mike Sperts will create an issue to propose adding a traits
+mechanism to check the compile-time properties through a template
+mechanism rather than macros
+
          
+
+
          
+Here is my attempt to do this. I don't believe that a separate trait is
+necessary for this, and that instead atomic_integral::is_lock_free can
+be re-purposed with minimal work as follows.
+
          
+
+
          [
+Howard: Put Benjamin's wording in the proposed wording section.
+]
          
+
+
+
          
+
+
          [
+2009-10-22 Alberto Ganesh Barbati:
+]
          
+
+
+
          
+
          
+Just a thought... wouldn't it be better to use a scoped enum instead of
+plain integers? For example:
+
          
+
+
          enum class is_lock_free
+{
+    never = 0, sometimes = 1, always = 2;
+};
+
          
+
+
          
+if compatibility with C is deemed important, we could use an unscoped
+enum with suitably chosen names.  It would still be more descriptive
+than 0, 1 and 2.
+
          
+
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2992.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Header <cstdatomic> synopsis  [atomics.synopsis]
+
          
+
+
          
+Edit  as follows:
+
          
+
+
          namespace std {
+...
+// 29.4, lock-free property
+#define ATOMIC_INTEGRAL_LOCK_FREE unspecified
+#define ATOMIC_CHAR_LOCK_FREE unspecified
+#define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+#define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+#define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+#define ATOMIC_SHORT_LOCK_FREE unspecified
+#define ATOMIC_INT_LOCK_FREE unspecified
+#define ATOMIC_LONG_LOCK_FREE unspecified
+#define ATOMIC_LLONG_LOCK_FREE unspecified
+#define ATOMIC_ADDRESS_LOCK_FREE unspecified
+
          
+
+
          
+Lock-free Property 29.4 [atomics.lockfree]
+
          
+
+
          
+Edit the synopsis as follows.
+
          
+
+
          namespace std {
+   #define ATOMIC_INTEGRAL_LOCK_FREE unspecified
+   #define ATOMIC_CHAR_LOCK_FREE unspecified
+   #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
+   #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
+   #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
+   #define ATOMIC_SHORT_LOCK_FREE unspecified
+   #define ATOMIC_INT_LOCK_FREE unspecified
+   #define ATOMIC_LONG_LOCK_FREE unspecified
+   #define ATOMIC_LLONG_LOCK_FREE unspecified
+   #define ATOMIC_ADDRESS_LOCK_FREE unspecified
+}
+
          
+
+
          
+Edit paragraph 1 as follows.
+
          
+
+
          
+The ATOMIC_...._LOCK_FREE macros ATOMIC_INTEGRAL_LOCK_FREE and ATOMIC_ADDRESS_LOCK_FREE indicate the general lock-free
+property of integral and address atomic the corresponding atomic integral types, with the
+signed and unsigned variants grouped together.
+The properties also apply to the corresponding specializations of the atomic template.
+A value of 0
+indicates that the types are never lock-free. A value of 1
+indicates that the types are sometimes lock-free. A value of 2
+indicates that the types are always lock-free.
+
          
+
+
          
+Operations on Atomic Types 29.6 [atomics.types.operations]
+
          
+
+
          
+Edit as follows.
+
          
+
+
          void static constexpr bool A::is_lock_free() const volatile;
+
          
+
          
+Returns: True if the object's types's operations are lock-free, false
+otherwise.
+
+[Note: In the same way that <limits>
+std::numeric_limits<short>::max() is related to
+<limits.h> __LONG_LONG_MAX__, <atomic>
+std::atomic_short::is_lock_free is related to
+<stdatomic.h> and ATOMIC_SHORT_LOCK_FREE —
+end note]
+
+
          
+
          
+
+
+
+
+
+
+
          
+
          1147. non-volatile atomic functions
          
+
          Section: 29.6 [atomics.types.operations] Status: NAD Editorial
+ Submitter: Jeffrey Yasskin Opened: 2009-06-16  Last modified: 2009-10-26
          
+
          View all other issues in [atomics.types.operations].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses US 90
          
+
+
          
+The C++0X draft
+declares all of the functions dealing with atomics (section 29.6 [atomics.types.operations])
+to take volatile arguments.
+Yet it also says (29.4-3),
+
          
+
+
          
+
          
+[ Note: Many operations are volatile-qualified.
+The "volatile as device register" semantics have not changed in the standard.
+This qualification means that volatility is preserved
+when applying these operations to volatile objects.
+It does not mean that operations on non-volatile objects become volatile.
+Thus, volatile qualified operations on non-volatile objects
+may be merged under some conditions. —end note ]
+
          
+
          
+
+
          
+I was thinking about how to implement this in gcc,
+and I believe that we'll want to overload most of the functions
+on volatile and non-volatile.
+Here's why:
+
          
+
+
          
+To let the compiler take advantage of the permission
+to merge non-volatile atomic operations and reorder atomics in certain,
+we'll need to tell the compiler backend
+about exactly which atomic operation was used.
+So I expect most of the functions of the form atomic_<op>_explicit()
+(e.g. atomic_load_explicit, atomic_exchange_explicit,
+atomic_fetch_add_explicit, etc.)
+to become compiler builtins.
+A builtin can tell whether its argument was volatile or not,
+so those functions don't really need extra explicit overloads.
+However, I don't expect that we'll want to add builtins
+for every function in chapter 29,
+since most can be implemented in terms of the _explicit free functions:
+
          
+
+
          class atomic_int {
+  __atomic_int_storage value;
+ public:
+  int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
+    // &value has type "volatile __atomic_int_storage*".
+    atomic_fetch_add_explicit(&value, increment, order);
+  }
+  ...
+};
+
          
+
+
          
+But now this always calls
+the volatile builtin version of atomic_fetch_add_explicit(),
+even if the atomic_int wasn't declared volatile.
+To preserve volatility and the compiler's permission to optimize,
+I'd need to write:
+
          
+
+
          class atomic_int {
+  __atomic_int_storage value;
+ public:
+  int fetch_add(int increment, memory_order order = memory_order_seq_cst) volatile {
+    atomic_fetch_add_explicit(&value, increment, order);
+  }
+  int fetch_add(int increment, memory_order order = memory_order_seq_cst) {
+    atomic_fetch_add_explicit(&value, increment, order);
+  }
+  ...
+};
+
          
+
+
          
+But this is visibly different from the declarations in the standard
+because it's now overloaded.
+(Consider passing &atomic_int::fetch_add as a template parameter.)
+
          
+
+
          
+The implementation may already have permission to add overloads
+to the member functions:
+
          
+
+
          
+
          
+17.6.4.5 [member.functions] An implementation may declare additional non-virtual
+member function signatures within a class:
          
+...
+
          
+
            
+
          • by adding a member function signature for a member function name.
            • 
+
          
+
          
+
+
          
+but I don't see an equivalent permission to add overloads to the free functions.
+
          
+
+
          [
+2009-06-16 Lawrence adds:
+]
          
+
+
+
          
+
          
+I recommend allowing non-volatile overloads.
+
          
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2992.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1148. Wrong argument type of I/O stream manipulators setprecision()
+and setw()
          
+
          Section: 27.7 [iostream.format] Status: NAD
+ Submitter: Marc Steinbach Opened: 2009-06-20  Last modified: 2009-10-20
          
+
          View all other issues in [iostream.format].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
          
+The header <iomanip> synopsis in 27.7 [iostream.format] specifies
+
          
+
          T5 setprecision(int n);
+T6 setw(int n);
+
          
+
+
          
+The argument types should be streamsize, as in class ios_base
+(see 27.5.2 [ios.base]):
+
          
+
          streamsize precision() const;
+streamsize precision(streamsize prec);
+streamsize width() const;
+streamsize width(streamsize wide);
+
          
+
+
          
+(Editorial: 'wide' should probably be renamed as 'width', or maybe just 'w'.)
+
          
+
+
          [
+2009-07-29 Daniel clarified wording.
+]
          
+
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+
          
+No concensus for this change.  There was some interest in doing the opposite
+fix:  Change the streamsize in <ios> to int.
+But ultimately there was no concensus for that change either.
+
          
+
          
+
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+In 27.7 [iostream.format], header <iomanip> synopsis change as indicated:
+
            
+
+
            T5 setprecision(intstreamsize n);
+T6 setw(intstreamsize n);
+
            
+
            2. 
+
+
          2. 
+
            
+In 27.7.3 [std.manip], just before p. 6 change as indicated:
+
            
+
+
            unspecified setprecision(intstreamsize n);
+
            
+
            3. 
+
+
          3. 
+
            
+In 27.7.3 [std.manip], just before p. 7 change as indicated:
+
            
+
+
            unspecified setw(intstreamsize n);
+
            
+
            4. 
+
          
+
+
+
+
+
+
+
+
+
          
+
          1149. Reformulating NonemptyRange axiom
          
+
          Section: 26.5.2.2 [rand.concept.urng] Status: NAD Concepts
+ Submitter: Walter Brown Opened: 2009-06-25  Last modified: 2009-07-15
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+In 26.5.2.2 [rand.concept.urng], we have the following:
+
          
+
          concept UniformRandomNumberGenerator<typename G> : Callable<G> {
+  ...
+  axiom NonemptyRange(G& g) {
+    G::min() < G::max();
+  }
+  ...
+}
+
          
+
+
          
+Since the parameter G is in scope throughout the concept, there is no
+need for the axiom to be further parameterized, and so the axiom can be
+slightly simplified as:
+
          
+
+
          axiom NonemptyRange()  {
+  G::min() < G::max();
+}
+
          
+
+
          
+We can further reformulate so as to avoid any axiom machinery as:
+
          
+
+
          requires True< G::min() < G::max() >;
+
          
+
+
          
+This is not only a simpler statement of the same requirement, but also
+forces the requirement to be checked.
+
          
+
+
+
          Proposed resolution:
          
+
          
+In 26.5.2.2 [rand.concept.urng], replace the NonemptyRange axiom by:
+
          
+
+
          axiom NonemptyRange(G& g) { 
+   G::min() < G::max(); 
+}
+requires True< G::min() < G::max() >;
+
          
+
+
+
+
+
+
+
          
+
          1150. wchar_t, char16_t and char32_t filenames
          
+
          Section: 27.9.1.14 [fstream] Status: NAD Future
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-20
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
          Addresses JP 73
          
+
+   
          Description
          
+        
          It is a problem
+        from C++98, fstream cannot appoint a filename of wide
+        character string(const wchar_t and const wstring&).
          
+
          Suggestion
          
+        
          Add
+        interface corresponding to wchar_t, char16_t and char32_t.
          
+
+
          [
+2009-07-01 Alisdair notes that this is a duplicate of 454 which has more
+in-depth rationale.
+]
          
+
+
+
          [
+2009-09-21 Daniel adds:
+]
          
+
+
+
          
+I suggest to mark this issue as NAD Future with the intend to
+solve the issue with a single file path c'tor template assuming
+a provision of a TR2 filesystem library.
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+NAD Future.  This is a duplicate of 454.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1155. Reference should be to C99
          
+
          Section: C.2 [diff.library] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-23
          
+
          View all other issues in [diff.library].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses FR 38
          
+
+
          Description
          
+        
          What is ISO/IEC 1990:9899/DAM
+        1? My guess is that's a typo for ISO/IEC
+        9899/Amd.1:1995 which I'd
+        have expected to be referenced here (the tables
+        make reference to things
+        which were introduced by Amd.1).
          
+
          Suggestion
          
+        
          One need probably a reference
+        to the document which introduce char16_t and
+        char32_t in C (ISO/IEC TR 19769:2004?).
          
+
          Notes
          
+
          Create issue. Document in question should be C99, not C90+amendment1. The 
+    rest of the section requires careful review for completeness. Example <cstdint> 
+    18.4.1 [cstdint.syn]. Assign to C liasons.
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial. Already fixed.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1160. future_error public constructor is 'exposition only'
          
+
          Section: 30.6.3 [futures.future_error] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 331
          
+
+
          Description
          
+        
          Not clear what
+        it means for a public constructor to be 'exposition only'.
+        If the intent is purely to support the library calling this
+        constructor then it can be made private and accessed
+        through friendship. Otherwise it should be documented for
+        public consumption.
          
+
          Suggestion
          
+        
          Declare the constructor as private with a
+        note about intended friendship, or remove the
+        exposition-only comment and document the semantics.
          
+
          Notes
          
+
          Create an issue. Assigned to Detlef. Suggested resolution probably makes 
+    sense.
          
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+Pending a paper from Anthony Williams / Detleff Volleman.
+
          
+
+
          [
+2009-10-14 Pending paper:
+N2967.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1161. Unnecessary unique_future limitations
          
+
          Section: 30.6.6 [futures.unique_future] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
          
+
          View all other issues in [futures.unique_future].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 336
          
+
+
          Description
          
+
+        
          It is possible
+        to transfer ownership of the asynchronous result from one
+        unique_future instance to another via the move-constructor.
+        However, it is not possible to transfer it back, and nor is
+        it possible to create a default-constructed unique_future
+        instance to use as a later move target. This unduly limits
+        the use of unique_future in code. Also, the lack of a
+        move-assignment operator restricts the use of unique_future
+        in containers such as std::vector - vector::insert requires
+        move-assignable for example.
          
+
          Suggestion
          
+        
          Add a default constructor with the
+        semantics that it creates a unique_future with no
+        associated asynchronous result. Add a move-assignment
+        operator which transfers ownership.
          
+
          Notes
          
+
          Create an issue. Detlef will look into it.
          
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+Pending a paper from Anthony Williams / Detleff Volleman.
+
          
+
+
          [
+2009-10-14 Pending paper:
+N2967.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1162. shared_future should support an efficient move constructor
          
+
          Section: 30.6.7 [future.shared_future] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
          
+
          View all other issues in [future.shared_future].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 337
          
+
+
          Description
          
+        
          shared_future
+        should support an efficient move constructor that can avoid
+        unnecessary manipulation of a reference count, much like
+        shared_ptr
          
+
          Suggestion
          
+        
          Add a move constructor
          
+
          Notes
          
+
          Create an issue. Detlef will look into it.
          
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+Pending a paper from Anthony Williams / Detleff Volleman.
+
          
+
+
          [
+2009-10-14 Pending paper:
+N2967.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1163. shared_future is inconsistent with shared_ptr
          
+
          Section: 30.6.7 [future.shared_future] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
          
+
          View all other issues in [future.shared_future].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 338
          
+
+
          Description
          
+
+        
          shared_future is currently
+        CopyConstructible, but not CopyAssignable. This is
+        inconsistent with shared_ptr, and will surprise users.
+        Users will then write work-arounds to provide this
+        behaviour. We should provide it simply and efficiently as
+        part of shared_future. Note that since the shared_future
+        member functions for accessing the state are all declared
+        const, the original usage of an immutable shared_future
+        value that can be freely copied by multiple threads can be
+        retained by declaring such an instance as "const
+        shared_future".
          
+
          Suggestion
          
+        
          Remove "=delete"
+        from the copy-assignment operator of shared_future. Add a
+        move-constructor shared_future(shared_future&&
+        rhs), and a move-assignment operator shared_future&
+        operator=(shared_future&& rhs). The postcondition
+        for the copy-assignment operator is that *this has the same
+        associated state as rhs. The postcondition for the
+        move-constructor and move assignment is that *this has the
+        same associated as rhs had before the
+        constructor/assignment call and that rhs has no associated
+        state.
          
+
          Notes
          
+
          Create an issue. Detlef will look into it.
          
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+Pending a paper from Anthony Williams / Detleff Volleman.
+
          
+
+
          [
+2009-10-14 Pending paper:
+N2967.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1164. promise::swap should pass by rvalue reference
          
+
          Section: 30.6.5 [futures.promise] Status: NAD
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
          
+
          View all other issues in [futures.promise].
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
+
          Addresses UK 341
          
+
+
          Description
          
+
          promise::swap accepts its parameter by lvalue reference. This is
+inconsistent with other types that provide a swap member function,
+where those swap functions accept an rvalue reference
          
+
+
          Suggestion
          
+
          Change promise::swap to take an rvalue reference.
          
+
+
          Notes
          
+
          Create an issue. Detlef will look into it. Probably ready as it.
            
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+NAD, by virtue of the changed rvalue rules and swap signatures from Summit.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1165. Unneeded promise move constructor
          
+
          Section: 30.6.5 [futures.promise] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
          
+
          View all other issues in [futures.promise].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses UK 343
          
+
+
          Description
          
+        
          The move constructor of a std::promise
+        object does not need to allocate any memory, so the
+        move-construct-with-allocator overload of the constructor
+        is superfluous.
          
+
          Suggestion
          
+        
          Remove the
+        constructor with the signature template <class
+        Allocator> promise(allocator_arg_t, const Allocator&
+        a, promise& rhs);
          
+
          Notes
          
+
          Create an issue. Detlef will look into it. Will solicit feedback from Pablo. 
+    Note that “rhs” argument should also be an rvalue reference in any case.
          
+
+
          [
+2009-07 Frankfurt
+]
          
+
+
+
          
+Pending a paper from Anthony Williams / Detleff Volleman.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2997.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1166. Allocator-specific move/copy break model of move-constructor and
+        move-assignment
          
+
          Section: X [allocator.propagation], X [allocator.propagation.map], 23 [containers] Status: NAD Editorial
+ Submitter: LWG Opened: 2009-06-28  Last modified: 2009-10-26
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
+
          Addresses US 77
          
+
+
          Description
          
+        
          Allocator-specific move and copy behavior for containers
+        (N2525) complicates a little-used and already-complicated
+        portion of the standard library (allocators), and breaks
+        the conceptual model of move-constructor and
+        move-assignment operations on standard containers being
+        efficient operations. The extensions for allocator-specific
+        move and copy behavior should be removed from the working
+        paper.
          
+        
          With the
+        introduction of rvalue references, we are teaching
+        programmers that moving from a standard container (e.g., a
+        vector<string>) is an efficient, constant-time
+        operation. The introduction of N2525 removed that
+        guarantee; depending on the behavior of four different
+        traits (20.8.4), the complexity of copy and move operations
+        can be constant or linear time. This level of customization
+        greatly increases the complexity of standard containers,
+        and benefits only a tiny fraction of the C++ community.
          
+
          Suggestion
          
+
+        
          Remove 20.8.4.
          
+        
+        
          Remove 20.8.5.
          
+        
+        
          Remove all references to the facilities in
+        20.8.4 and 20.8.5 from clause 23.
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Addressed by
+N2982.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1167. pair<T,U> doesn't model LessThanComparable in unconstrained code even if
+      T and U do.
          
+
          Section: 20.3.4 [pairs] Status: NAD Concepts
+ Submitter: Dave Abrahams Opened: 2009-07-01  Last modified: 2009-07-16
          
+
          View other active issues in [pairs].
          
+
          View all other issues in [pairs].
          
+
          View all issues with NAD Concepts status.
          
+
          Discussion:
          
+
          
+LessThanComparable requires (and provides default
+             implementations for) <=,>, and >=.  However, the defaults
+             don't take effect in unconstrained code.
+
          
+
          
+Still, it's a problem to have types acting one way in
+constrained code and another in unconstrained code, except in cases of
+syntax adaptation.  It's also inconsistent with the containers, which
+supply all those operators.
+
          
+
          
+Totally Unbiased
+Suggested Resolution:
+
          
+
          
+accept the exported concept maps proposal and
+                    change the way this stuff is handled to use an
+                    explicit exported concept map rather than nested
+                    function templates
+
          
+
          
+e.g., remove from the body of std::list
+
          
+
          template <LessThanComparable T, class Allocator> 
+bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y); 
+template <LessThanComparable T, class Allocator> 
+bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y); 
+template <LessThanComparable T, class Allocator> 
+bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y); 
+template <LessThanComparable T, class Allocator> 
+bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y); 
+
          
+
          
+and add this concept_map afterwards:
+
          
+
          template <LessThanComparable T, class Allocator> 
+export concept_map LessThanComparable<list<T,Allocator> >
+{
+    bool operator<(const list<T,Allocator>& x, const list<T,Allocator>& y);
+}
+
          
+
          
+do similarly for std::pair.  While you're at it, do the same for
+operator== and != everywhere, and seek out other such opportunities.
+
          
+
          
+Alternative Resolution: keep the ugly, complex specification and add the
+                       missing operators to std::pair.
+
          
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1168. Odd wording for bitset equality operators
          
+
          Section: 20.3.7.2 [bitset.members] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-07-02  Last modified: 2009-07-27
          
+
          View all other issues in [bitset.members].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+The following wording seems a little unusual to me:
+
          
+
          
+p42/43 20.3.7.2 [bitset.members]
+
          
+
+
          
+
          bool operator==(const bitset<N>& rhs) const;
+
          
+
          
+-42- Returns: A nonzero value if the value of each bit in
+*this equals the value of the corresponding bit in
+rhs.
+
          
+
          bool operator!=(const bitset<N>& rhs) const;
+
          
+
          
+-43- Returns: A nonzero value if !(*this == rhs).
+
          
+
          
+
+
          
+"A nonzero value" may be well defined as equivalent to the literal 'true'
+for Booleans, but the wording is clumsy.  I suggest replacing "A nonzero value"
+with the literal 'true' (in appropriate font) in each case.
+
          
+
+
          [
+2009-07-24 Alisdair recommends NAD Editorial.
+]
          
+
+
+
          [
+2009-07-27 Pete adds:
+]
          
+
+
+
          
+It's obviously editorial. There's no need for further discussion.
+
          
+
+
          [
+2009-07-27 Howard sets to NAD Editorial.
+]
          
+
+
+
+
+
          Proposed resolution:
          
+
          
+Change 20.3.7.2 [bitset.members] p42-43:
+
          
+
+
          
+
          bool operator==(const bitset<N>& rhs) const;
+
          
+
          
+-42- Returns: A nonzero value true if the value of each bit in
+*this equals the value of the corresponding bit in
+rhs.
+
          
+
          bool operator!=(const bitset<N>& rhs) const;
+
          
+
          
+-43- Returns: A nonzero value true if !(*this == rhs).
+
          
+
          
+
+
+
+
+
+
+
          
+
          1172. select_on_container_(copy|move)_construction over-constrained
          
+
          Section: X [allocator.concepts.members] Status: NAD Editorial
+ Submitter: Alberto Ganesh Barbati Opened: 2009-07-08  Last modified: 2009-10-26
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+I believe the two functions
+select_on_container_(copy|move)_construction() are over-constrained. For
+example, the return value of the "copy" version is (see
+X [allocator.concepts.members]/21):
+
          
+
          
+Returns: x if the allocator should propagate from the existing
+container to the new container on copy construction, otherwise X().
+
          
+
          
+Consider the case where a user decides to provide an explicit concept
+map for Allocator to adapt some legacy allocator class, as he wishes to
+provide customizations that the LegacyAllocator concept map template
+does not provide.  Now, although it's true that the legacy class is
+required to have a default constructor, the user might have reasons to
+prefer a different constructor to implement
+select_on_container_copy_construction(). However, the current wording
+requires the use of the default constructor.
+
          
+
          
+Moreover, it's not said explicitly that x is supposed to be the
+allocator of the existing container. A clarification would do no harm.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Addressed by
+N2982.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Replace X [allocator.concepts.members]/21 with:
+
          
+
+
          X select_on_container_copy_construction(const X& x);
+
          
+
          
+-21- Returns: x if the allocator should propagate from the existing
+container to the new container on copy construction, otherwise X().
+an allocator object to be used by the new container on copy
+construction. [Note: x is the allocator of the existing container that
+is being copied. The most obvious choices for the return value are x, if
+the allocator should propagate from the existing container, and X().
+— end note]
+
          
+
          
+
+
          
+Replace X [allocator.concepts.members]/25 with:
+
          
+
+
          X select_on_container_move_construction(X&& x);
+
          
+
          
+-25- Returns: move(x) if the allocator should propagate from the existing
+container to the new container on move construction, otherwise X().
+an allocator object to be used by the new container on move
+construction. [Note: x is the allocator of the existing container that
+is being moved. The most obvious choices for the return value are move(x), if
+the allocator should propagate from the existing container, and X().
+— end note]
+
          
+
          
+
+
+
+
+
+
+
          
+
          1174. type property predicates
          
+
          Section: 20.6.4.3 [meta.unary.prop] Status: NAD Editorial
+ Submitter: Jason Merrill Opened: 2009-07-16  Last modified: 2009-10-26
          
+
          View other active issues in [meta.unary.prop].
          
+
          View all other issues in [meta.unary.prop].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+I've been implementing compiler support for is_standard_layout, and
+noticed a few nits about 20.6.4.3 [meta.unary.prop]:
+
          
+
+
            
+
          1. 
+There's no trait for "trivially copyable type", which is now the
+property that lets you do bitwise copying of a type, and therefore seems
+useful to be able to query.  has_trivial_assign &&
+has_trivial_copy_constructor && has_trivial_destructor
+is similar, but
+not identical, specifically with respect to const types.
+
            2. 
+
          2. 
+has_trivial_copy_constructor and has_trivial_assign lack the "or an
+array of such a class type" language that most other traits in that
+section, including has_nothrow_copy_constructor and has_nothrow_assign,
+have; this seems like an oversight.
+
            3. 
+
          
+
+
          [
+See the thread starting with c++std-lib-24420 for further discussion.
+]
          
+
+
+
          [
+Addressed in N2947.
+]
          
+
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Editorial.  Solved by
+N2984.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+
          
+
+
+
+
+
+
          
+
          1179. Probably editorial in [structure.specifications]
          
+
          Section: 17.5.1.4 [structure.specifications] Status: NAD Editorial
+ Submitter: Robert Klarer Opened: 2009-07-21  Last modified: 2009-10-20
          
+
          View all other issues in [structure.specifications].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+While reviewing 971 I noted that 17.5.1.4 [structure.specifications]/7 says:
+
          
+
+
          
+-7- Error conditions specify conditions where a function may fail. The
+conditions are listed, together with a suitable explanation, as the enum
+class errc constants (19.5) that could be used as an argument to
+function make_error_condition (19.5.3.6).
+
          
+
+
          
+This paragraph should mention make_error_code or the text "that
+could be used as an argument to function make_error_condition
+(19.5.3.6)" should be deleted.  I believe this is editorial.
+
          
+
+
          [
+2009-07-21 Chris adds:
+]
          
+
+
+
          
+
          
+I'm not convinced there's a problem there, because as far as the "Error
+conditions" clauses are concerned, make_error_condition() is used by a
+user to test for the condition, whereas make_error_code is not. For
+example:
+
          
+
+
          void foobar(error_code& ec = throws());
+
          
+
+
          
+ Error conditions:
+
          
+
          
+permission_denied - Insufficient privilege to perform operation.
+
          
+
+
          
+When a user writes:
+
          
+
+
          error_code ec;
+foobar(ec);
+if (ec == errc::permission_denied)
+   ...
+
          
+
+
          
+the implicit conversion errc->error_condition makes the if-test
+equivalent to:
+
          
+
+
          if (ec == make_error_condition(errc::permission_denied))
+
          
+
+
          
+On the other hand, if the user had written:
+
          
+
+
          if (ec == make_error_code(errc::permission_denied))
+
          
+
+
          
+the test is now checking for a specific error code. The test may
+evaluate to false even though foobar() failed due to the documented
+error condition "Insufficient privilege".
+
          
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+
          
+NAD Editorial.
+
          
+
          
+What the WP says right now is literally true: these codes can be used as
+an argument to make_error_condition. (It is also true that they can be
+used as an argument to make_error_code, which the WP doesn't say.) Maybe
+it would be clearer to just delete "that could be used as an argument to
+function make_error_condition", since that fact is already implied by
+other things that we say. We believe that this is editorial.
+
          
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+
          
+
+
+
+
+
+
          
+
          1184. Feature request: dynamic bitset
          
+
          Section: 23.3.6 [vector] Status: NAD Future
+ Submitter: Alisdair Meredith Opened: 2009-07-29  Last modified: 2009-10-26
          
+
          View all other issues in [vector].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
          
+Opened at Alisdair's request, steming from 96.
+Alisdair recommends NAD Future.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Future.  We want a heap allocated bitset, but we don't have one today and
+don't have time to add one.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1195. "Diagnostic required" wording is insufficient to  prevent UB
          
+
          Section: 17 [library] Status: NAD Editorial
+ Submitter: Daniel Krügler Opened: 2009-08-18  Last modified: 2009-10-20
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+Several parts of the library use the notion of "Diagnostic required"
+to indicate that
+in the corresponding situation an error diagnostic should occur, e.g.
+20.8.14.1.1 [unique.ptr.dltr.dflt]/2
+
          
+
          void operator()(T *ptr) const;
+
          
+
+
          
+Effects: calls delete on ptr. A diagnostic is required if T is an
+incomplete type.
+
          
+
          
+
+
          
+The problem with this approach is that such a requirement is
+insufficient to prevent
+undefined behavior, if this situation occurs. According to 1.3.3 [defns.diagnostic]
+a diagnostic message is defined as
+
          
+
+
          
+a message belonging to an implementation-defined subset of the
+implementation's output messages.
+
          
+
+
          
+which doesn't indicate any relation to an ill-formed program. In fact,
+"compiler warnings"
+are a typical expression of such diagnostics. This means that above
+wording can be interpreted
+by compiler writers that they satisfy the requirements of the standard
+if they just produce
+such a "warning", if the compiler happens to compile code like this:
+
          
+
+
          #include <memory>
+
+struct Ukn; // defined somewhere else
+Ukn* create_ukn(); // defined somewhere else
+
+int main() {
+ std::default_delete<Ukn>()(create_ukn());
+}
+
          
+
+
          
+In this and other examples discussed here it was the authors intent to
+guarantee that the
+program is ill-formed with a required diagnostic, therefore such
+wording should be used instead.
+According to the general rules outlined in 1.4 [intro.compliance] it
+should be sufficient
+to require that these situations produce an ill-formed program and the
+"diagnostic
+required" part should be implied. The proposed resolution also
+suggests to remove
+several redundant wording of "Diagnostics required" to ensure that
+the absence of
+such saying does not cause a misleading interpretation.
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+
          
+Move to NAD.
+
          
+
          It's not clear that there's any important difference between
+"ill-formed" and "diagnostic required". From 1.4 [intro.compliance],
+1.3.5 [defns.ill.formed], and 1.3.15 [defns.well.formed] it appears
+that an ill-formed program is one
+that is not correctly constructed according to the syntax rules and
+diagnosable semantic rules, which means that... "a conforming
+implementation shall issue at least one diagnostic message." The
+author's intent seems to be that we should be requiring a fatal error
+instead of a mere warning, but the standard just doesn't have language
+to express that distinction. The strongest thing we can ever require is
+a "diagnostic".
+
          
+
          
+The proposed rewording may be a clearer way of expressing the same thing
+that the WP already says, but such a rewording is editorial.
+
          
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+Considered again.  Group disagrees that the change is technical, but likes
+it editorially.  Moved to NAD Editorial.
+
          
+
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+Change 20.4 [ratio]/2 as indicated:
+
            
+
+
+
+
            
+Throughout this subclause, the template argument types R1 and R2 shall
+be specializations of the ratio
+template, else the program is ill-formed. Diagnostic required.
+
            
+
            2. 
+
+
          2. 
+
            
+Change 20.4.1 [ratio.ratio]/1 as indicated:
+
            
+
+
            
+The template argument D shall not be zero, and the absolute values of
+the template arguments N and D shall
+be representable by type intmax_t, else the program is ill-formed. Diagnostic required. [..]
+
            
+
+
+
            3. 
+
+
          3. 
+
            
+Change 20.4.2 [ratio.arithmetic]/1 as indicated:
+
            
+
+
            
+Implementations may use other algorithms to compute these values.
+If overflow would occurs, a diagnostic shall
+be issuedthe program shall be ill-formed.
+
            
+
+
            4. 
+
+
          4. 
+
            
+Change 20.4.3 [ratio.comparison]/2 as indicated:
+
            
+
+
            
+[...] Implementations may use other algorithms to compute this relationship
+to avoid overflow. If
+overflow occurs, a diagnostic is required would occur,
+the program shall be
+ill-formed.
+
            
+
+
+
            5. 
+
+
          5. 
+
            
+Change 20.8.14.1.1 [unique.ptr.dltr.dflt]/2 as indicated:
+
            
+
+
            
+
            
+Effects: calls delete on ptr. A diagnostic is required if T is an
+incomplete type.
+
            
+
+
            
+Remarks: The program shall be ill-formed, if T is an incomplete type.
+
            
+
            
+
+
+
            6. 
+
+
          6. 
+
            
+Change 20.8.14.1.2 [unique.ptr.dltr.dflt1]/1 as indicated:
+
            
+
+
            
+
            
+operator() calls delete[] on ptr. A diagnostic is required if T
+is an incomplete type.
+
            
+
+
            
+Remarks: The program shall be ill-formed, if T is an incomplete type.
+
            
+
            
+
            7. 
+
+
          7. 
+
            
+Accept 932.
+
            
+
+
            [This is a bullet here to confirm that this list is
+an exhaustive review of this issue.]
            
+
+
            8. 
+
+
          8. 
+
            
+Accept 950.
+
            
+
+
            [This is a bullet here to confirm that this list is
+an exhaustive review of this issue.]
            
+
+
            9. 
+
+
          9. 
+
            
+Change 20.8.14.3 [unique.ptr.runtime]/1 as indicated:
+
            
+
+
            
+[..]
+-- Conversions among different types of unique_ptr<T[], D> or to or
+from the non-array forms of
+unique_ptr are disallowed (diagnostic required)
+produce an ill-formed program.
+[..]
+
            
+
+
+
            10. 
+
+
          10. 
+
            
+Change 20.9.3 [time.duration]/2 as indicated:
+
            
+
+
            
+Requires: Rep shall be an arithmetic type or a class emulating an
+arithmetic type. If a program
+instantiates duration with a duration type for the template argument
+Rep a diagnostic is required.
+Remarks: The program shall be ill-formed, if duration is
+instantiated with a duration type for the template argument Rep.
+
+
            
+
+
+
            11. 
+
+
          11. 
+
            
+Change 20.9.3 [time.duration]/3+4 as indicated:
+
            
+
+
            
+
            
+3 RequiresRemarks: Period shall be a
+specialization of ratio, diagnostic
+requiredelse the program shall be ill-formed.
+
            
+
+
            
+4 RequiresRemarks: Period::num shall be
+positive,  diagnostic
+requiredelse the program shall be ill-formed.
+
            
+
            
+
+
+
            12. 
+
+
          12. 
+
            
+Accept 1177 bullet 1.
+
            
+
+
            [This is a bullet here to confirm that this list is
+an exhaustive review of this issue.]
            
+
+
+
            13. 
+
+
          13. 
+
            
+Accept 1177 bullet 2.
+
            
+
+
            [This is a bullet here to confirm that this list is
+an exhaustive review of this issue.]
            
+
+
+
            14. 
+
+
          14. 
+
            
+Accept 1177 bullet 3.
+
            
+
+
            [This is a bullet here to confirm that this list is
+an exhaustive review of this issue.]
            
+
+
+
            15. 
+
+
          15. 
+
            
+Change 20.9.4 [time.point]/2 as indicated:
+
            
+
+
            
+Duration shall be an instance of duration, else the
+program shall be ill-formed. Diagnostic required.
+
            
+
            16. 
+
+
          16. 
+
            
+Change 20.9.4.1 [time.point.cons]/3 as indicated:
+
            
+
+
            
+
            
+Requires: Duration2 shall be implicitly convertible to duration.
+Diagnostic required.
+
            
+
+
            
+Remarks: Duration2 shall be implicitly convertible to duration,
+else this constructor shall
+not participate in overload resolution.
+
            
+
            
+
+
            [This suggestion seems more in sync to the several suggested changes
+of 1177, 950, etc.]
            
+
+
            17. 
+
+
          17. 
+
            
+Accept 1177 bullet 4.
+
            
+
+
            [This is a bullet here to confirm that this list is
+an exhaustive review of this issue.]
            
+
+
+
            18. 
+
+
          
+
+
+
+
+
+
+
          
+
          1196. move semantics undefined for priority_queue
          
+
          Section: 23.3.5.2.1 [priqueue.cons] Status: NAD Editorial
+ Submitter: Alisdair Meredith Opened: 2009-08-19  Last modified: 2009-10-20
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+The class template priority_queue declares signatures for a move
+constructor and move assignment operator in its class definition.
+However, it does not provide a definition (unlike std::queue, and
+proposed resolution for std::stack.) Nor does it provide a text clause
+specifying their behaviour.
+
          
+
+
          [
+2009-08-23 Daniel adds:
+]
          
+
+
+
          
+1194 provides wording that solves this issue.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Mark NAD Editorial, solved by issue 1194.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1203. More useful rvalue stream insertion
          
+
          Section: 27.7.2.9 [ostream.rvalue], 27.7.1.6 [istream.rvalue] Status: NAD Future
+ Submitter: Howard Hinnant Opened: 2009-09-06  Last modified: 2009-10-20
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
          
+27.7.2.9 [ostream.rvalue] was created to preserve the ability to insert
+into (and extract from 27.7.1.6 [istream.rvalue]) rvalue streams:
+
          
+
+
          template <class charT, class traits, class T>
+  basic_ostream<charT, traits>&
+  operator<<(basic_ostream<charT, traits>&& os, const T& x);
+
          
+
          
+
          
+1 Effects: os << x
+
          
+
          
+2 Returns: os
+
          
+
          
+
          
+
+
          
+This is good as it allows code that wants to (for example) open, write to, and
+close an ofstream all in one statement:
+
          
+
+
          std::ofstream("log file") << "Some message\n";
+
          
+
+
          
+However, I think we can easily make this "rvalue stream helper" even easier to
+use.  Consider trying to quickly create a formatted string.  With the current
+spec you have to write:
+
          
+
+
          std::string s = static_cast<std::ostringstream&>(std::ostringstream() << "i = " << i).str();
+
          
+
+
          
+This will store "i = 10" (for example) in the string s.  Note
+the need to cast the stream back to ostringstream& prior to using
+the member .str().  This is necessary because the inserter has cast
+the ostringstream down to a more generic ostream during the
+insertion process.
+
          
+
+
          
+I believe we can re-specify the rvalue-inserter so that this cast is unnecessary.
+Thus our customer now has to only type:
+
          
+
+
          std::string s = (std::ostringstream() << "i = " << i).str();
+
          
+
+
          
+This is accomplished by having the rvalue stream inserter return an rvalue of
+the same type, instead of casting it down to the base class.  This is done by
+making the stream generic, and constraining it to be an rvalue of a type derived
+from ios_base.
+
          
+
+
          
+The same argument and solution also applies to the inserter.  This code has been
+implemented and tested.
+
          
+
+
          [
+2009 Santa Cruz:
+]
          
+
+
+
          
+NAD Future.  No concensus for change.
+
          
+
+
+
+
          Proposed resolution:
          
+
          
+Change 27.7.1.6 [istream.rvalue]:
+
          
+
+
          template <class charT, class traits Istream, class T>
+  basic_istream<charT, traits>& Istream&&
+  operator>>(basic_istream<charT, traits> Istream&& is, T& x);
+
          
+
          
+
          
+1 Effects: is >> x
+
          
+
          
+2 Returns: std::move(is)
+
          
+
          
+3 Remarks: This signature shall participate in overload resolution if
+and only if Istream is not an lvalue reference type and is derived from
+ios_base.
+
          
+
          
+
          
+
+
          
+Change 27.7.2.9 [ostream.rvalue]:
+
          
+
+
          template <class charT, class traits Ostream, class T>
+  basic_ostream<charT, traits>& Ostream&&
+  operator<<(basic_ostream<charT, traits> Ostream&& os, const T& x);
+
          
+
          
+
          
+1 Effects: os << x
+
          
+
          
+2 Returns: std::move(os)
+
          
+
          
+3 Remarks: This signature shall participate in overload resolution if
+and only if Ostream is not an lvalue reference type and is derived from
+ios_base.
+
          
+
          
+
          
+
+
+
+
+
+
+
          
+
          1217. Quaternion support
          
+
          Section: 26.4 [complex.numbers] Status: NAD Future
+ Submitter: Ted Shaneyfelt Opened: 2009-09-26  Last modified: 2009-10-26
          
+
          View all other issues in [complex.numbers].
          
+
          View all issues with NAD Future status.
          
+
          Discussion:
          
+
          
+Concerning mathematically proper operation of the type:
+
          
+
+
          complex<complex<T> >
+
          
+
+
          
+Generally accepted mathematical semantics of such a construct correspond
+to quaternions through Cayly-Dickson construct
+
          
+
+
          (w+xi) + (y+zi) j
+
          
+
+
          
+The proper implementation seems straightforward by adding a few
+declarations like those below. I have included operator definition for
+combining real scalars and complex types, as well, which seems
+appropriate, as algebra of complex numbers allows mixing complex and
+real numbers with operators. It also allows for constructs such as
+complex<double> i=(0,1),  x = 12.34 + 5*i;
+
          
+
+
          
+Quaternions are often used in areas such as computer graphics, where,
+for example, they avoid the problem of Gimbal lock when rotating objects
+in 3D space, and can be more efficient than matrix multiplications,
+although I am applying them to a different field.
+
          
+
+
          /////////////////////////ALLOW OPERATORS TO COMBINE REAL SCALARS AND COMPLEX VALUES /////////////////////////
+template<typename T,typename S> complex<T> operator+(const complex<T> x,const S a) {
+    complex<T> result(x.real()+a, x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator+(const S a,const complex<T> x) {
+    complex<T> result(a+x.real(), x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator-(const complex<T> x,const S a) {
+    complex<T> result(x.real()-a, x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator-(const S a,const complex<T> x) {
+    complex<T> result(a-x.real(), x.imag());
+    return result;
+}
+template<typename T,typename S> complex<T> operator*(const complex<T> x,const S a) {
+    complex<T> result(x.real()*a, x.imag()*a);
+    return result;
+}
+template<typename T,typename S> complex<T> operator*(const S a,const complex<T> x) {
+    complex<T> result(a*x.real(), a*x.imag());
+    return result;
+}
+
+/////////////////////////PROPERLY IMPLEMENT QUATERNION SEMANTICS/////////////////////////
+template<typename T> double normSq(const complex<complex<T> >q) {
+    return q.real().real()*q.real().real()
+         + q.real().imag()*q.real().imag()
+         + q.imag().real()*q.imag().real()
+         + q.imag().imag()*q.imag().imag();
+}
+template<typename T> double norm(const complex<complex<T> >q) {
+    return sqrt(normSq(q));
+}
+/////// Cayley-Dickson Construction
+template<typename T> complex<complex<T> > conj(const complex<complex<T> > x) {
+    complex<complex<T> > result(conj(x.real()),-x.imag());
+    return result;
+}
+template<typename T> complex<complex<T> > operator*(const complex<complex<T> > ab,const complex<complex<T> > cd) {
+    complex<T> re(ab.real()*cd.real()-conj(cd.imag())*ab.imag());
+    complex<T> im(cd.imag()*ab.real()+ab.imag()*conj(cd.real()));
+    complex<complex<double> > q(re,im);
+    return q;
+}
+//// Quaternion division
+template<typename S,typename T> complex<complex<T> > operator/(const complex<complex<T> > q,const S a) {
+    return q * (1/a);
+}
+template<typename S,typename T> complex<complex<T> > operator/(const S a,const complex<complex<T> > q) {
+    return a*conj(q)/normSq(q);
+}
+template<typename T> complex<complex<T> > operator/(const complex<complex<T> > n, const complex<complex<T> > d) {
+    return n * (conj(d)/normSq(d));
+}
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD Future.  There is no consensus or time to move this into C++0X.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
+
+
+
+
          
+
          1229. error_code operator= typo
          
+
          Section: 19.5.2.3 [syserr.errcode.modifiers] Status: NAD
+ Submitter: Stephan T. Lavavej Opened: 2009-10-08  Last modified: 2009-10-26
          
+
          View all issues with NAD status.
          
+
          Discussion:
          
+
          
+N2960
+19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers] say:
+
          
+
+
           
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value>::type&
+    operator=(ErrorCodeEnum e);
+
          
+
+
          
+They should say:
+
          
+
+
           
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type&
+    operator=(ErrorCodeEnum e);
+
          
+
+
          
+Or (I prefer this form):
+
          
+ 
+
           
+template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code&>::type
+    operator=(ErrorCodeEnum e);
+
          
+
+
          
+This is because enable_if is declared as (20.6.7 [meta.trans.other]):
+
          
+ 
+
           
+template <bool B, class T = void> struct enable_if;
+
          
+
+
          
+So, the current wording makes operator= return
+void&, which is not good.
+
          
+
+
           
+19.5.2.3 [syserr.errcode.modifiers]/4 says
+
          
+
+
          
+Returns: *this.
+
          
+
          
+which is correct.
+
          
+
+
          
+Additionally,
+
          
+
+
          
+19.5.3.1 [syserr.errcondition.overview]/1 says:
+
          
+ 
+
           
+template<typename ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>, error_code>::type &
+    operator=( ErrorConditionEnum e );
+
          
+
+
          
+Which contains several problems (typename versus class
+inconsistency, lack of ::value, error_code instead of
+error_condition), while 19.5.3.3 [syserr.errcondition.modifiers] says:
+
          
+ 
+
           
+template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value>::type&
+    operator=(ErrorConditionEnum e);
+
          
+
+
          
+Which returns void&.  They should both say:
+
          
+ 
+
           
+template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type&
+    operator=(ErrorConditionEnum e);
+
          
+
+
          
+Or (again, I prefer this form):
+
          
+
+
           
+template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition&>::type
+    operator=(ErrorConditionEnum e);
+
          
+
+
          
+Additionally, 19.5.3.3 [syserr.errcondition.modifiers] lacks a
+"Returns: *this." paragraph, which is presumably
+necessary.
+
          
+
+
          [
+2009-10-18 Beman adds:
+]
          
+
+
+
          
+The proposed resolution for issue 1237 makes this issue
+moot, so it should become NAD.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+NAD, solved by 1237.
+
          
+
+
+
+
          Proposed resolution:
          
+
+
          
+Change 19.5.2.1 [syserr.errcode.overview] and 19.5.2.3 [syserr.errcode.modifiers]:
+
          
+
+
          template <class ErrorCodeEnum>
+  typename enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code&>::type&
+    operator=(ErrorCodeEnum e);
+
          
+
+
          
+Change 19.5.3.1 [syserr.errcondition.overview]:
+
          
+
+
          template<typename class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_conditionde&>::type &
+    operator=( ErrorConditionEnum e );
+
          
+
+
          
+Change 19.5.3.3 [syserr.errcondition.modifiers]:
+
          
+
+
          template <class ErrorConditionEnum>
+  typename enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition&>::type&
+    operator=(ErrorConditionEnum e);
+
          
+
          
+
          
+Postcondition: *this == make_error_condition(e).
+
          
+
          
+Returns: *this.
+
          
+
          
+Throws: Nothing.
+
          
+
          
+
          
+
+
+
+
+
+
+
          
+
          1230. mem_fn and variadic templates
          
+
          Section: 20.7.14 [func.memfn] Status: Dup
+ Submitter: Alisdair Meredith Opened: 2009-10-09  Last modified: 2009-10-23
          
+
          View all other issues in [func.memfn].
          
+
          View all issues with Dup status.
          
+
          Duplicate of: 920
          
+
          Discussion:
          
+
+
+
 
          
- Header <unordered_map> synopsis
+Since we have removed the entry in B [implimits] for the
+library-specific limit for number of arguments passed to
+function/tuple/etc. I believe we need to update the
+spec for mem_fn to reflect this.
 
          
-
           namespace std {
-   // 23.5.1, class template unordered_map:
-   template <ValueType Key,
-             ValueType T,
-             Callable<auto, const Key&> Hash = hash<Key>,
-             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
-             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-     requires NothrowDestructible<Key> && NothrowDestructible<T>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-     class unordered_map;
 
-   // 23.5.2, class template unordered_multimap:
-   template <ValueType Key,
-             ValueType T,
-             Callable<auto, const Key&> Hash = hash<Key>,
-             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
-             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-     requires NothrowDestructible<Key> && NothrowDestructible<T>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-     class unordered_multimap;
+
          
+The "Remarks: Implementations may implement mem_fn as a set of
+overloaded function templates." no longer holds, as we cannot create an
+arbitrary number of such overloads.  I believe we should strike the
+remark and add a second signature:
+
          
 
-   ...
- }
+
          template<class R, class T, typename ... ArgTypes>
+  unspecified mem_fn(R (T::*pm)(ArgTypes...));
 
          
 
 
          
- Header <unordered_set> synopsis
+I believe we need two signatures as pointer-to-data-member and
+pointer-to-member-function-taking-no-args appear to use subtly different
+syntax.
 
          
-
           namespace std {
-   // 23.5.3, class template unordered_set:
-   template <ValueType Value,
-             Callable<auto, const Value&> Hash = hash<Value>,
-             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
-             Allocator Alloc = allocator<Value> >
-     requires NothrowDestructible<Value>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-     class unordered_set;
 
-   // 23.5.4, class template unordered_multiset:
-   template <ValueType Value,
-             Callable<auto, const Value&> Hash = hash<Value>,
-             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
-             Allocator Alloc = allocator<Value> >
-     requires NothrowDestructible<Value>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-     class unordered_multiset;
+
          [
+920 as a similar proposed resolution.
+]
          
 
-   ...
- }
+
+
+
          Proposed resolution:
          
+Add to 20.7 [function.objects] and 20.7.14 [func.memfn]:
+
+
+
          template<class R, class T> unspecified mem_fn(R T::* pm)
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...));
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...)&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile&);
+
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...)&&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const&&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) volatile&&);
+template<class R, class T, class ...Args> unspecified mem_fn(R (T::* pm)(Args...) const volatile&&);
 
          
 
 
          
- 23.5.1p3 Class template unordered_map [unord.map]
+Strike 20.7.14 [func.memfn], p5:
 
          
-
           namespace std {
-   template <ValueType Key,
-             ValueType T,
-             Callable<auto, const Key&> Hash = hash<Key>,
-             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
-             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-     requires NothrowDestructible<Key> && NothrowDestructible<T>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-   class unordered_map
-   {
-     ...
-   };
- }
+
+
          
+Remarks: Implementations may implement mem_fn as a set
+of overloaded function templates.
+
          
+
+
+
+
+
          
+
          1232. Still swap's with rvalue-references
          
+
          Section: 17 [library] Status: NAD Editorial
+ Submitter: Daniel Krügler Opened: 2009-10-11  Last modified: 2009-10-29
          
+
          View other active issues in [library].
          
+
          View all other issues in [library].
          
+
          View all issues with NAD Editorial status.
          
+
          Discussion:
          
+
          
+The current library contains still rvalue reference-swaps that seem to be
+overlooked in the process of switching back to lvalue-ref swaps.
+
          
+
+
          [
+2009-10 Santa Cruz:
+]
          
+
+
+
          
+Editor accepts as NAD Editorial.
+
          
+
+
+
+
          Proposed resolution:
          
+
            
+
          1. 
+
            
+Change 20.3.4 [pairs]/1 as indicated:
+
            
+
+
            template <class T1, class T2>
+struct pair {
+  ...
+  void swap(pair&& p);
+};
 
            
+
            2. 
 
+
          2. 
 
            
- 23.5.2p3 Class template unordered_multimap [unord.multimap]
+Change 20.3.4 [pairs] before p. 17 as indicated:
 
            
-
             namespace std {
-   template <ValueType Key,
-             ValueType T,
-             Callable<auto, const Key&> Hash = hash<Key>,
-             PredicateEquivalenceRelation<auto, Key, Key> Pred = equal_to<Key>,
-             Allocator Alloc = allocator<pair&lt;<b>const Key, T> > >
-     requires NothrowDestructible<Key> && NothrowDestructible<T>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-   class unordered_multimap
-   {
-     ...
-   };
- }
+
+
            void swap(pair&& p);
 
            
 
+
            3. 
+
+
          3. 
+
 
            
- 23.5.3p3 Class template unordered_set [unord.set]
+Change 20.3.4 [pairs] before p. 21 as indicated:
 
            
-
             namespace std {
-   template <ValueType Value,
-             Callable<auto, const Value&> Hash = hash<Value>,
-             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
-             Allocator Alloc = allocator<Value> >
-     requires NothrowDestructible<Value>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-   class unordered_set
-   {
-     ...
-   };
- }
+
+
            template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y);
+template<class T1, class T2> void swap(pair<T1, T2>&& x, pair<T1, T2>& y);
+template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>&& y);
 
            
+
+
            4. 
+
+
          4. 
 
            
- 23.5.4p3 Class template unordered_multiset [unord.multiset]
+Change 20.5.1 [tuple.general]/2, header <tuple> synopsis, as indicated:
 
            
-
             namespace std {
-   template <ValueType Value,
-             Callable<auto, const Value&> Hash = hash<Value>,
-             PredicateEquivalenceRelation<auto, Value, Value> class Pred = equal_to<Value>,
-             Allocator Alloc = allocator<Value> >
-     requires NothrowDestructible<Value>
-           && SameType<Hash::result_type, size_t>
-           && CopyConstructible<Hash> && CopyConstructible<Pred>
-           && AllocatableElement<Alloc, Pred, const Pred&>
-           && AllocatableElement<Alloc, Pred, Pred&&>
-           && AllocatableElement<Alloc, Hash, const Hash&>
-           && AllocatableElement<Alloc, Hash, Hash&&>
-   class unordered_multiset
-   {
-     ...
-   };
- }
+
+
            // 20.5.2.9, specialized algorithms:
+template <class... Types>
+void swap(tuple<Types...>& x, tuple<Types...>& y);
+template <class... Types>
+void swap(tuple<Types...>&& x, tuple<Types...>& y);
+template <class... Types>
+void swap(tuple<Types...>& x, tuple<Types...>&& y);
+
            
+
+
            5. 
+
+
          5. 
+
            
+Change 20.5.2 [tuple.tuple] as indicated:
+
            
+
+
            // 20.5.2.3, tuple swap
+void swap(tuple&&)
+
            
+
+
            6. 
+
+
          6. 
+
            
+Change 20.5.2.3 [tuple.swap] before 1 as indicated:
+
            
+
+
            void swap(tuple&& rhs);
+
            
+
+
            7. 
+
+
          7. 
+
            
+Change 20.7 [function.objects]/2, header <functional> synopsis, as indicated:
+
            
+
+
            template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&&, function<R(ArgTypes...)>&);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)&&);
+
            
+
+
            8. 
+
+
          8. 
+
            
+Change 20.7.15.2 [func.wrap.func], as indicated:
+
            
+
+
            // 20.7.15.2.2, function modifiers:
+void swap(function&&);
+template<class F, class A> void assign(F, const A&);
+
+[..]
+
+// 20.7.15.2.7, specialized algorithms:
+template <class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
+template <class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&&, function<R(ArgTypes...)>&);
+template <class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&&);
+
            
+
+
            9. 
+
+
          9. 
+
            
+Change 20.7.15.2.7 [func.wrap.func.alg] before 1 as indicated:
+
            
+
+
            template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>& f2);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>&& f1, function<R(ArgTypes...)>& f2);
+template<class R, class... ArgTypes>
+void swap(function<R(ArgTypes...)>& f1, function<R(ArgTypes...)>&& f2);
 
            
 
-
          
+
          2. 
+
+
        2. 
+
          
+Change 20.8.15.2 [util.smartptr.shared]/1 as indicated:
+
          
+
+
          // 20.8.12.2.4, modifiers:
+void swap(shared_ptr&& r);
+
+[..]
 
+// 20.8.12.2.9, shared_ptr specialized algorithms:
+template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b);
+template<class T> void swap(shared_ptr<T>&& a, shared_ptr<T>& b);
+template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>&& b);
+
          
 
+
          3. 
 
+
        3. 
+
          
+Change 21.3 [string.classes]/1, header <string> synopsis, as indicated:
+
          
 
+
          // 21.4.8.8: swap
+template<class charT, class traits, class Allocator>
+void swap(basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>& rhs);
+template<class charT, class traits, class Allocator>
+void swap(basic_string<charT,traits,Allocator>&& lhs, basic_string<charT,traits,Allocator>& rhs);
+template<class charT, class traits, class Allocator>
+void swap(basic_string<charT,traits,Allocator>& lhs, basic_string<charT,traits,Allocator>&& rhs);
+
          
 
+
          4. 
 
-
          
-
          1124.  Invalid definition of concept RvalueOf
          
-
          Section: 20.2.1 [concept.transform] Status: NAD Concepts
- Submitter: Daniel Krügler Opened: 2009-05-28  Last modified: 2009-07-15
          
-
          View all other issues in [concept.transform].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
        4. 
 
          
-A recent news group
-article
-points to several defects in the
-specification of reference-related concepts.
+Change 23.3 [sequences]/1, header <deque> synopsis, as indicated:
 
          
+
+
          template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+
          
+
+
          5. 
+
+
        5. 
 
          
-One problem of the concept RvalueOf as currently defined in
-20.2.1 [concept.transform]:
+Change 23.3 [sequences]/1, header <list> synopsis, as indicated:
 
          
 
-
          concept RvalueOf<typename T> {
- typename type = T&&;
- requires ExplicitlyConvertible<T&,type> && Convertible<T&&,type>;
-}
-
-template<typename T> concept_map RvalueOf<T&> {
- typedef T&& type;
-}
+
          template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
 
          
 
+
          6. 
+
+
        6. 
 
          
-is that if T is an lvalue-reference, the requirement
-Convertible<T&&,type> isn't satisfied for
-lvalue-references, because after reference-collapsing in the concept
-definition we have Convertible<T&,type> in this case,
-which isn't satisfied in the concept map template and also is not the
-right constraint either. I think that the reporter is right that
-SameType requirements should do the job and that we also should
-use the new RvalueReference concept to specify a best matching
-type requirement.
+Change 23.3 [sequences]/1, header <queue> synopsis, as indicated:
 
          
 
+
          template <class T, class Allocator>
+void swap(queue<T, Container>& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>&& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>&& y);
 
-
          Proposed resolution:
          
+template <class T, class Container = vector<T>, class Compare = less<typename Container::value_type> >
+class priority_queue;
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>&& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>&& y);
+
          
+
+
          7. 
+
+
        7. 
 
          
-In 20.2.1 [concept.transform] before p. 4 change as indicated:
+Change 23.3 [sequences]/1, header <stack> synopsis, as indicated:
 
          
 
-
          auto concept RvalueOf<typename T> {
-  typenameRvalueReference type = T&&;
-  requires ExplicitlyConvertible<T&, type> && Convertible<T&&, type>SameType<T&, type&>;
-}
+
          template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>&& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>&& y);
 
          
 
+
          8. 
 
+
        8. 
+
          
+Change 23.3 [sequences]/1, header <vector> synopsis, as indicated:
+
          
 
+
          template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+
          
 
+
          9. 
 
-
          
-
          1127. rvalue references and iterator traits
          
-
          Section: D.10.1 [iterator.traits] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-07-15
          
-
          View all other issues in [iterator.traits].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
        9. 
 
          
-The deprecated support for iterator_traits and legacy (unconstrained)
-iterators features the (exposition only) concept:
+Change 23.3.2 [deque]/2 as indicated:
 
          
 
-
          concept IsReference<typename T> { } // exposition only
-template<typename T> concept_map IsReference<T&> { }
+
          iterator erase(const_iterator position);
+iterator erase(const_iterator first, const_iterator last);
+void swap(deque<T,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
 
          
+
+
          10. 
+
+
        10. 
 
          
-Now this looks exactly like the LvalueReference concept recently added to
-clause 20, so I wonder if we should use that instead?
-Then I consider the lack of rvalue-reference support, which means that
-move_iterator would always flag as merely supporting the input_iterator_tag
-category.  This suggests we retain the exposition concept, but add a second
-concept_map to support rvalue references.
+Change 23.3.2.4 [deque.special] as indicated:
 
          
+
+
          template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+
          
+
+
          11. 
+
+
        11. 
 
          
-I would suggest adding the extra concept_map is the right way forward, but
-still wonder if the two exposition-only concepts in this clause might be
-worth promoting to clause 20.  That question might better be answered with a
-fuller investigation of type_trait/concept unification though.
+Change 23.3.3 [forwardlist]/2 as indicated:
 
          
 
+
          iterator erase_after(const_iterator position);
+iterator erase_after(const_iterator position, iterator last);
+void swap(forward_list<T,Allocator>&&);
 
-
          Proposed resolution:
          
+[..]
+
+// 23.3.3.6 specialized algorithms:
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
+
          
+
+
          12. 
+
+
        12. 
 
          
-In Iterator traits D.10.1 [iterator.traits] para 4 add:
+Change 23.3.3.6 [forwardlist.spec] as indicated:
 
          
 
-
          concept IsReference<typename T> { } // exposition only
-template<typename T> concept_map IsReference<T&> { }
-template<typename T> concept_map IsReference<T&&> { }
+
          template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
 
          
 
+
          13. 
+
+
        13. 
+
          
+Change 23.3.4 [list]/2 as indicated:
+
          
 
+
          iterator erase(const_iterator position);
+iterator erase(const_iterator position, const_iterator last);
+void swap(list<T,Allocator>&&);
+void clear();
 
+[..]
 
+// specialized algorithms:
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+
          
 
+
          14. 
 
-
          
-
          1128. Missing definition of iterator_traits<T*>
          
-
          Section: 24.3 [iterator.syn] Status: NAD Concepts
- Submitter: Alisdair Meredith Opened: 2009-05-28  Last modified: 2009-07-16
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
        14. 
 
          
-The <iterator> header synopsis declares a partial specialization of
-iterator_traits to support pointers, 24.3 [iterator.syn].  The implication
-is that specialization will be described in D10, yet it did not follow the
-rest of the deprecated material into this clause.
+Change 23.3.4.5 [list.special] as indicated:
 
          
+
+
          template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+
          
+
+
          15. 
+
+
        15. 
 
          
-However, this is not as bad as it first seems!
-There are partial specializations of iterator_traits for types that satisfy
-the various Iterator concepts, and there are concept_maps for pointers to
-explicitly support the RandomAccessIterator concept, so the required
-template will be present - just not in the manner advertised.
+Change 23.3.5.1.1 [queue.defn] as indicated:
 
          
+
+
          void swap(queue&& q) { c.swap(q.c); }
+
+[..]
+
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>&& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>&& y);
+
          
+
+
          16. 
+
+
        16. 
 
          
-I can see two obvious solutions:
+Change 23.3.5.1.3 [queue.special] as indicated:
 
          
 
-
            
-
          1. 
-Restore the iterator_traits<T*> partial specialization in D.10
+
            template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>&& x, queue<T, Container>& y);
+template <class T, class Container>
+void swap(queue<T, Container>& x, queue<T, Container>&& y);
+
            
+
 
            2. 
+
 
          2. 
-Remove the declaration of iterator_traits<T*> from 24.3 synopsis
-
            3. 
-
          
 
          
-I recommend option (ii) in the wording below
+Change 23.3.5.2 [priority.queue]/1 as indicated:
 
          
+
+
          void swap(priority_queue&&);
+
+// no equality is provided
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>&& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, class Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>&& y);
+
          
+
+
          17. 
+
+
        17. 
 
          
-Option (ii) could be extended to strike all the declarations of deprecated
-material from the synopsis, as it is effectively duplicating D.10 anyway.
-This is the approach taken for deprecated library components in the 98/03
-standards.  This is probably a matter best left to the Editor though.
+Change 23.3.5.2.3 [priqueue.special] as indicated:
 
          
 
+
          template <class T, class Container, Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, Compare>
+void swap(priority_queue<T, Container, Compare>&& x, priority_queue<T, Container, Compare>& y);
+template <class T, class Container, Compare>
+void swap(priority_queue<T, Container, Compare>& x, priority_queue<T, Container, Compare>&& y);
+
          
+
+
          18. 
 
-
          Proposed resolution:
          
+
        18. 
 
          
-In 24.3 [iterator.syn] strike:
+Change 23.3.5.3.1 [stack.defn] as indicated:
 
          
 
-
          template<class T> struct iterator_traits<T*>;
-
          
+
          void swap(stack&& s) { c.swap(s.c); }
 
+[..]
 
+template <class T, class Allocator>
+void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(stack<T,Allocator>&& x, stack<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(stack<T,Allocator>& x, stack<T,Allocator>&& y);
+
          
 
 
+
          19. 
 
+
        19. 
+
          
+Change 23.3.5.3.3 [stack.special] as indicated:
+
          
 
-
          
-
          1139. Thread support library not concept enabled
          
-
          Section: 30 [thread] Status: NAD Concepts
- Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
-
          View all other issues in [thread].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
          template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>&& x, stack<T, Container>& y);
+template <class T, class Container>
+void swap(stack<T, Container>& x, stack<T, Container>&& y);
+
          
 
-
          Addresses US 93, JP 79, UK 333, JP 81
          
+
          20. 
 
+
        20. 
 
          
-The thread chapter is not concept enabled.
+Change 23.3.6 [vector]/2 as indicated:
 
          
 
+
          void swap(vector<T,Allocator>&&);
+void clear();
 
+[..]
 
-
          Proposed resolution:
          
+// specialized algorithms:
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+
          
 
+
          21. 
 
+
        21. 
+
          
+Change 23.3.6.2 [vector.capacity] before p. 8 as indicated:
+
          
 
+
          void swap(vector<T,Allocator>&& x);
+
          
 
+
          22. 
 
-
          
-
          1140. Numerics library not concept enabled
          
-
          Section: 26 [numerics] Status: NAD Concepts
- Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
-
          View all other issues in [numerics].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+
        22. 
+
          
+Change 23.3.6.5 [vector.special] as indicated:
+
          
 
-
          Addresses US 84
          
+
          template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
+template <class T, class Allocator>
+void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+
          
+
+
          23. 
 
+
        23. 
 
          
-The numerics chapter is not concept enabled.
+Change 23.3.7 [vector.bool]/1 as indicated:
 
          
 
+
          iterator erase(const_iterator first, const_iterator last);
+void swap(vector<bool,Allocator>&&);
+static void swap(reference x, reference y);
+
          
+
+
          24. 
+
+
        24. 
 
          
-The portion of this comment dealing with random numbers was resolved by
-N2836,
-which was accepted in Summit.
+Change 23.4 [associative]/1, header <map> synopsis as indicated:
 
          
 
+
          template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator&& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator& x, map<Key,T,Compare,Allocator>&& y);
 
+[..]
 
-
          Proposed resolution:
          
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator&& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator& x, multimap<Key,T,Compare,Allocator>&& y);
+
          
 
+
          25. 
 
+
        25. 
+
          
+Change 23.4 [associative]/1, header <set> synopsis as indicated:
+
          
 
+
          template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(set<Key,T,Compare,Allocator&& x, set<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(set<Key,T,Compare,Allocator& x, set<Key,T,Compare,Allocator>&& y);
 
+[..]
 
-
          
-
          1141. Input/Output library not concept enabled
          
-
          Section: 27 [input.output] Status: NAD Concepts
- Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
-
          View all other issues in [input.output].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multiset<Key,T,Compare,Allocator&& x, multiset<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multiset<Key,T,Compare,Allocator& x, multiset<Key,T,Compare,Allocator>&& y);
+
          
 
-
          Addresses US 85, JP 67, JP 68, JP 69, JP 72, UK 308
          
+
          26. 
 
+
        26. 
 
          
-The input/output chapter is not concept enabled.
+Change 23.4.1 [map]/2 as indicated:
+
          
+
+
          iterator erase(const_iterator first, const_iterator last);
+void swap(map<Key,T,Compare,Allocator>&&);
+void clear();
+
+[..]
+
+// specialized algorithms:
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator&& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator& x, map<Key,T,Compare,Allocator>&& y);
+
          
+
+
          27. 
+
+
        27. 
+
          
+Change 23.4.1.5 [map.special] as indicated:
 
          
 
+
          template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>&& x, map<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>&& y);
+
          
 
+
          28. 
 
-
          Proposed resolution:
          
-
-
+
        28. 
+
          
+Change 23.4.2 [multimap]/2 as indicated:
+
          
 
+
          iterator erase(const_iterator first, const_iterator last);
+void swap(multimap<Key,T,Compare,Allocator>&&);
+void clear();
 
+[..]
 
-
          
-
          1142. Regular expressions library not concept enabled
          
-
          Section: 28 [re] Status: NAD Concepts
- Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
-
          View all other issues in [re].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+// specialized algorithms:
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator&& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator& x, multimap<Key,T,Compare,Allocator>&& y);
+
          
 
-
          Addresses US 86, UK 309, UK 310
          
+
          29. 
 
+
        29. 
 
          
-The regular expressions chapter is not concept enabled.
+Change 23.4.2.4 [multimap.special] as indicated:
 
          
 
+
          template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>&& x, multimap<Key,T,Compare,Allocator>& y);
+template <class Key, class T, class Compare, class Allocator>
+void swap(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>&& y);
+
          
 
+
          30. 
 
-
          Proposed resolution:
          
+
        30. 
+
          
+Change 23.4.3 [set]/2 and 23.4.3.2 [set.special] as indicated: (twice!)
+
          
 
+
          // specialized algorithms:
+template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator>& x, set<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator&& x, set<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(set<Key,Compare,Allocator& x, set<Key,Compare,Allocator>&& y);
+
          
 
+
          31. 
 
+
        31. 
+
          
+Change 23.4.4 [multiset]/2 as indicated:
+
          
 
+
          iterator erase(const_iterator first, const_iterator last);
+void swap(multiset<Key,Compare,Allocator>&&);
+void clear();
 
-
          
-
          1143. Atomic operations library not concept enabled
          
-
          Section: 29 [atomics] Status: NAD Concepts
- Submitter: LWG Opened: 2009-06-15  Last modified: 2009-07-15
          
-
          View other active issues in [atomics].
          
-
          View all other issues in [atomics].
          
-
          View all issues with NAD Concepts status.
          
-
          Discussion:
          
+[..]
 
-
          Addresses US 87, UK 311
          
+// specialized algorithms:
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator&& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator& x, multiset<Key,Compare,Allocator>&& y);
+
          
 
-
          
-The atomics chapter is not concept enabled.
-
          
+
          32. 
 
+
        32. 
 
          
-Needs to also consider issues 923 and 924.
+Change 23.4.4.2 [multiset.special] as indicated:
 
          
 
+
          template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>&& x, multiset<Key,Compare,Allocator>& y);
+template <class Key, class Compare, class Allocator>
+void swap(multiset<Key,Compare,Allocator>& x, multiset<Key,Compare,Allocator>&& y);
+
          
 
-
-
          Proposed resolution:
          
+
          33. 
+
        
 
 
 
 
 
 
        
-
        1149. Reformulating NonemptyRange axiom
        
-
        Section: 26.5.2.2 [rand.concept.urng] Status: NAD Concepts
- Submitter: Walter Brown Opened: 2009-06-25  Last modified: 2009-07-15
        
-
        View all issues with NAD Concepts status.
        
+
        1235. Issue with C++0x random number proposal
        
+
        Section: 26.5.2.5 [rand.concept.dist] Status: NAD Future
+ Submitter: Matthias Troyer Opened: 2009-10-12  Last modified: 2009-10-26
        
+
        View all issues with NAD Future status.
        
 
        Discussion:
        
 
        
-In 26.5.2.2 [rand.concept.urng], we have the following:
+There exist optimized, vectorized vendor libraries for the creation of
+random number generators, such as Intel's MKL [1] and AMD's ACML [2]. In
+timing tests we have seen a performance gain of a factor of up to 80
+(eighty) compared to a pure C++ implementation (in Boost.Random) when
+using these generator to generate a sequence of normally distributed
+random numbers. In codes dominated by the generation of random numbers
+(we have application codes where random number generation is more than
+50% of the CPU time) this factor 80 is very significant.
 
        
-
        concept UniformRandomNumberGenerator<typename G> : Callable<G> {
-  ...
-  axiom NonemptyRange(G& g) {
-    G::min() < G::max();
-  }
-  ...
-}
-
        
 
 
        
-Since the parameter G is in scope throughout the concept, there is no
-need for the axiom to be further parameterized, and so the axiom can be
-slightly simplified as:
+To make use of these vectorized generators, we use a C++ class modeling
+the RandomNumberEngine concept and forwarding the generation of random
+numbers to those optimized generators. For example:
 
        
 
-
        axiom NonemptyRange()  {
-  G::min() < G::max();
+
        namespace mkl {
+ class mt19937 {.... };
 }
 
        
 
 
        
-We can further reformulate so as to avoid any axiom machinery as:
+For the generation of random variates we also want to dispatch to
+optimized vectorized functions in the MKL or ACML libraries. See this
+example:
 
        
 
-
        requires True< G::min() < G::max() >;
+
        mkl::mt19937 eng;
+std::normal_distribution<double> dist;
+
+double n = dist(eng);
 
        
 
 
        
-This is not only a simpler statement of the same requirement, but also
-forces the requirement to be checked.
+Since the variate generation is done through the operator() of the
+distribution there is no customization point to dispatch to Intel's or
+AMD's optimized functions to generate normally distributed numbers based
+on the mt19937 generator. Hence, the performance gain of 80 cannot be
+achieved.
 
        
 
-
-
        Proposed resolution:
        
 
        
-In 26.5.2.2 [rand.concept.urng], replace the NonemptyRange axiom by:
+Contrast this with TR1:
 
        
 
-
        axiom NonemptyRange(G& g) { 
-   G::min() < G::max(); 
-}
-requires True< G::min() < G::max() >;
+
        mkl::mt19937 eng;
+std::tr1::normal_distribution<double> dist;
+std::tr1::variate_generator<mkl::mt19937,std::tr1::normal_distribution<double> > rng(eng,dist);
+double n = rng();
 
        
 
+
        
+This - admittedly much uglier from an aestethic point of view - design
+allowed optimization by specializing the variate_generator template for
+mkl::mt19937:
+
        
 
+
        namespace std { namespace tr1 {
 
+template<>
+class variate_generator<mkl::mt19937,std::tr1::normal_distribution<double> > { .... };
 
+} }
+
        
 
+
        
+A similar customization point is missing in the C++0x design and
+prevents the optimized vectorized version to be used.
+
        
 
-
        
-
        1164. promise::swap should pass by rvalue reference
        
-
        Section: 30.6.4 [futures.promise] Status: NAD
- Submitter: LWG Opened: 2009-06-28  Last modified: 2009-07-17
        
-
        View other active issues in [futures.promise].
        
-
        View all other issues in [futures.promise].
        
-
        View all issues with NAD status.
        
-
        Discussion:
        
-
-
        Addresses UK 341
        
+
        
+Suggested resolution:
+
        
 
-
        Description
        
-
        promise::swap accepts its parameter by lvalue reference. This is
-inconsistent with other types that provide a swap member function,
-where those swap functions accept an rvalue reference
        
+
        
+Add a customization point to the distribution concept. Instead of the
+variate_generator template this can be done through a call to a
+free function generate_variate found by ADL instead of
+operator() of the distribution:
+
        
 
-
        Suggestion
        
-
        Change promise::swap to take an rvalue reference.
        
+
        template <RandomNumberDistribution, class RandomNumberEngine>
+typename RandomNumberDistribution ::result_type
+generate_variate(RandomNumberDistribution const& dist, RandomNumberEngine& eng);
+
        
 
-
        Notes
        
-
        Create an issue. Detlef will look into it. Probably ready as it.
          
+
        
+This function can be overloaded for optimized enginges like
+mkl::mt19937.
+
        
 
 
        [
-2009-07 Frankfurt
+2009-10 Santa Cruz:
 ]
        
 
 
 
        
-NAD, by virtue of the changed rvalue rules and swap signatures from Summit.
+NAD Future.  No time to add this feature for C++0X.
 
        
 
 
@@ -28165,63 +40641,75 @@ NAD, by virtue of the changed rvalue rules and swap signatures from Summit.
 
 
 
        
-
        1167. pair<T,U> doesn't model LessThanComparable in unconstrained code even if
-      T and U do.
        
-
        Section: 20.3.3 [pairs] Status: NAD Concepts
- Submitter: Dave Abrahams Opened: 2009-07-01  Last modified: 2009-07-16
        
-
        View other active issues in [pairs].
        
-
        View all other issues in [pairs].
        
-
        View all issues with NAD Concepts status.
        
+
        1236. reserved identifiers in programs not using the library
        
+
        Section: 17 [library] Status: NAD
+ Submitter: Sean Hunt Opened: 2009-10-13  Last modified: 2009-10-20
        
+
        View other active issues in [library].
        
+
        View all other issues in [library].
        
+
        View all issues with NAD status.
        
 
        Discussion:
        
 
        
-LessThanComparable requires (and provides default
-             implementations for) <=,>, and >=.  However, the defaults
-             don't take effect in unconstrained code.
-
        
-
        
-Still, it's a problem to have types acting one way in
-constrained code and another in unconstrained code, except in cases of
-syntax adaptation.  It's also inconsistent with the containers, which
-supply all those operators.
-
        
-
        
-Totally Unbiased
-Suggested Resolution:
-
        
-
        
-accept the exported concept maps proposal and
-                    change the way this stuff is handled to use an
-                    explicit exported concept map rather than nested
-                    function templates
-
        
-
        
-e.g., remove from the body of std::list
+I wasn't sure whether to consider this a library or a language issue,
+because the issue is I think it's incorrectly categorized as being part
+of the library, so I thought I'd send a message to both of you and let
+you sort it out.
 
        
-
        template <LessThanComparable T, class Allocator> 
-bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y); 
-template <LessThanComparable T, class Allocator> 
-bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y); 
-template <LessThanComparable T, class Allocator> 
-bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y); 
-template <LessThanComparable T, class Allocator> 
-bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y); 
-
        
+
 
        
-and add this concept_map afterwards:
+Most reserved identifiers are treated as unilaterally available to the
+implementation, such as to implement language extensions, or provide
+macros documenting its functionality. However, the requirements for
+reserved identifers are in 17.6.3.3 [reserved.names], which are a
+subsection of 17.6.3 [constraints]. 17.6.3.1 [constraints.overview] appears only to apply to "C++ programs
+that use the facilities of the C++ standard library", meaning that, in
+theory, all implementations are erroneous in having any non-standard
+identifiers predefined for programs that do not, at some point, include
+a standard library header.
 
        
-
        template <LessThanComparable T, class Allocator> 
-export concept_map LessThanComparable<list<T,Allocator> >
-{
-    bool operator<(const list<T,Allocator>& x, const list<T,Allocator>& y);
-}
-
        
-
        
-do similarly for std::pair.  While you're at it, do the same for
-operator== and != everywhere, and seek out other such opportunities.
+
+
        Furthermore, it's unclear whether the use of certain identifiers is
+UB
+or results in an ill-formed program. In particular, 17.6.3.3.1
+[macro.names] uses a "shall not", where 17.6.3.3.2 [global.names] says
+that names are "reserved to the
+implementation". 17.6.3.3 [reserved.names] seems only to cover the
+instance of a name being described as "reserved", so are
+implementations
+required to diagnose a program that performs, as an example, "#undef
+get"?
 
        
+
+
        [
+2009 Santa Cruz:
+]
        
+
+
+
        
+Move to NAD. There may in theory be multiple interpretations possible,
+but there's no evidence that this causes any genuine problems or
+uncertainty about what implementations are allowed to do. We do not
+believe this rises to the level of a defect.
+
        
+
+
+
+
        Proposed resolution:
        
+
+
+
+
+
+
        
+
        1242. Enable SCARY iterators
        
+
        Section: 23 [containers] Status: NAD Future
+ Submitter: Herb Sutter Opened: 2009-10-21  Last modified: 2009-10-21
        
+
        View other active issues in [containers].
        
+
        View all other issues in [containers].
        
+
        View all issues with NAD Future status.
        
+
        Discussion:
        
 
        
-Alternative Resolution: keep the ugly, complex specification and add the
-                       missing operators to std::pair.
+See
+N2980.
 
        
 
 
@@ -28232,81 +40720,85 @@ Alternative Resolution: keep the ugly, complex specification and add the
 
 
 
        
-
        1168. Odd wording for bitset equality operators
        
-
        Section: 20.3.6.2 [bitset.members] Status: NAD Editorial
- Submitter: Alisdair Meredith Opened: 2009-07-02  Last modified: 2009-07-27
        
-
        View all other issues in [bitset.members].
        
-
        View all issues with NAD Editorial status.
        
+
        1243. Missing operator+= (initializer_list<T>) for valarray
        
+
        Section: 26.6.2.6 [valarray.cassign] Status: NAD
+ Submitter: Daniel Krügler Opened: 2009-10-22  Last modified: 2009-10-26
        
+
        View all other issues in [valarray.cassign].
        
+
        View all issues with NAD status.
        
 
        Discussion:
        
+
        Addresses JP 64
        
+
 
        
-The following wording seems a little unusual to me:
+During the additions of initializer_list overloads
+basic_string added
 
        
+
+
        basic_string& operator+=(initializer_list<charT>);
+
        
+
 
        
-p42/43 20.3.6.2 [bitset.members]
+but
 
        
 
-
        
-
        bool operator==(const bitset<N>& rhs) const;
-
        
-
        
--42- Returns: A nonzero value if the value of each bit in
-*this equals the value of the corresponding bit in
-rhs.
-
        
-
        bool operator!=(const bitset<N>& rhs) const;
-
        
-
        
--43- Returns: A nonzero value if !(*this == rhs).
-
        
-
        
+
        valarray<T>& operator+= (initializer_list<T>);
+
        
 
 
        
-"A nonzero value" may be well defined as equivalent to the literal 'true'
-for Booleans, but the wording is clumsy.  I suggest replacing "A nonzero value"
-with the literal 'true' (in appropriate font) in each case.
+was not defined.
 
        
 
 
        [
-2009-07-24 Alisdair recommends NAD Editorial.
+Daniel adds on opening:
 ]
        
 
 
+
        
+Recommend NAD. The operator+= overload of basic_string
+behaves as-if calling append, which is completely different in
+meaning as the existing operator+= overloads in
+valarray which just sum the value or values to the existing
+elements. The suggestion to add a corresponding append function to
+valarray was not considered as appropriate and the request was
+withdrawn (c++std-lib-24968).
+
        
+
 
        [
-2009-07-27 Pete adds:
+2009-10 Santa Cruz:
 ]
        
 
 
 
        
-It's obviously editorial. There's no need for further discussion.
+Mark as NAD.  Request has been withdrawn by NB.
 
        
 
-
        [
-2009-07-27 Howard sets to NAD Editorial.
-]
        
 
 
+
        Proposed resolution:
        
+
        
+Add to 26.6.2.6 [valarray.cassign]:
+
        
 
+
        valarray<T>& operator+= (initializer_list<T>);
+
        
 
-
        Proposed resolution:
        
+
+
+
+
+
        
+
        1248. Equality comparison for unordered containers
        
+
        Section: 23.5 [unord] Status: NAD Future
+ Submitter: Herb Sutter Opened: 2009-10-25  Last modified: 2009-10-25
        
+
        View all other issues in [unord].
        
+
        View all issues with NAD Future status.
        
+
        Discussion:
        
 
        
-Change 20.3.6.2 [bitset.members] p42-43:
+See
+N2986.
 
        
 
-
        
-
        bool operator==(const bitset<N>& rhs) const;
-
        
-
        
--42- Returns: A nonzero value true if the value of each bit in
-*this equals the value of the corresponding bit in
-rhs.
-
        
-
        bool operator!=(const bitset<N>& rhs) const;
-
        
-
        
--43- Returns: A nonzero value true if !(*this == rhs).
-
        
-
        
 
+
        Proposed resolution:
        
 
 
 
diff --git a/libstdc++-v3/doc/html/ext/lwg-defects.html b/libstdc++-v3/doc/html/ext/lwg-defects.html
index 17eb1ecfa8f..0201cfbd739 100644
--- a/libstdc++-v3/doc/html/ext/lwg-defects.html
+++ b/libstdc++-v3/doc/html/ext/lwg-defects.html
@@ -7,6 +7,14 @@
 
@@ -14,11 +22,11 @@ del {background-color:#FFA0A0}
 
-
+
-
+
@@ -29,7 +37,7 @@ del {background-color:#FFA0A0}
 
        
 
        
 Doc. no.N2941=09-0131N3012=09-0202
 
        
 
        
 Date:2009-08-022009-11-08
 
        
 
        
 Project:Howard Hinnant <howard.hinnant@gmail.com>
 
        
 
        
-
        C++ Standard Library Defect Report List (Revision R66)
        
+
        C++ Standard Library Defect Report List (Revision R68)
        
 
   
        Reference ISO/IEC IS 14882:2003(E)
        
   
        Also see:
        
@@ -51,6 +59,76 @@ del {background-color:#FFA0A0}
 
 
        Revision History
        
 
@@ -112,24 +190,24 @@ del {background-color:#FFA0A0}
 
      3. 1143 issues total, up by 32.
        4. 
 
        4. 
 
      4. Details:
        5. 
 
 
@@ -142,7 +220,7 @@ del {background-color:#FFA0A0}
 
      5. 1111 issues total, up by 19.
        6. 
 
 
      6. Details:
        7. 
@@ -159,9 +237,9 @@ del {background-color:#FFA0A0}
 
      7. Details:
        8. 
 
@@ -192,7 +270,7 @@ del {background-color:#FFA0A0}
 
      8. 982 issues total, up by 44.
        9. 
 
 
      9. Details:
        10. 
 
 
@@ -205,7 +283,7 @@ del {background-color:#FFA0A0}
 
      10. 938 issues total, up by 20.
        11. 
 
 
      11. Details:
        12. 
 
 
@@ -219,28 +297,28 @@ del {background-color:#FFA0A0}
 
 
      12. Details:
        13. 
 
@@ -254,7 +332,7 @@ del {background-color:#FFA0A0}
 
      13. 878 issues total, up by 9.
        14. 
 
 
      14. Details:
        15. 
 
 
@@ -285,21 +363,21 @@ del {background-color:#FFA0A0}
 
 
      15. Details:
        16. 
 
      16. Details:
        17. 
 
@@ -331,7 +409,7 @@ del {background-color:#FFA0A0}
 
      17. Details:
        18. 
 
      18. Details:
          
 
        • Added the following New issues: 755, 756, 757, 758, 759, 760, 761, 762, 763, 764.
          • 
-
        • Changed the following issues from NAD to Open: 463.
          • 
+
        • Changed the following issues from NAD to Open: 463.
          • 
 
        • Changed the following issues from Pending WP to WP: 607, 608, 654, 655, 677, 682.
          • 
 
        19. 
 
@@ -402,7 +480,7 @@ del {background-color:#FFA0A0}
 
      19. Changed the following issues from NAD Future to Dup: 77, 350.
        20. 
 
      20. Changed the following issues from New to NAD: 639, 657, 663.
        21. 
 
      21. Changed the following issues from Open to NAD: 548.
        22. 
-
      22. Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
        23. 
+
      23. Changed the following issues from New to Open: 546, 550, 564, 565, 573, 585, 588, 627, 629, 630, 632, 635, 653, 659, 667, 668, 669, 670, 671, 673, 686, 704, 707, 708.
        24. 
 
      24. Changed the following issues from New to Pending NAD Editorial: 393, 592.
        25. 
 
      25. Changed the following issues from New to Pending WP: 607, 608, 654, 655, 677, 682.
        26. 
 
      26. Changed the following issues from New to Ready: 561, 562, 563, 567, 581, 595, 620, 621, 622, 623, 624, 661, 664, 665, 666, 674, 675, 676, 679, 687, 688, 689, 693, 694, 695, 700, 703, 705, 706.
        27. 
@@ -423,7 +501,7 @@ del {background-color:#FFA0A0}
 
      27. 723 issues total, up by 15.
        28. 
 
 
      28. Details:
        29. 
 
 
@@ -463,7 +541,7 @@ del {background-color:#FFA0A0}
 
      29. 696 issues total, up by 20.
        30. 
 
 
      30. Details:
        31. 
 
      31. Details:
        32. 
 
      32. Details:
        33. 
 
@@ -525,7 +603,7 @@ del {background-color:#FFA0A0}
 
      33. 619 issues total, up by 10.
        34. 
 
 
      34. Details:
        35. 
 
 
@@ -557,7 +635,7 @@ del {background-color:#FFA0A0}
 
      35. 592 issues total, up by 5.
        36. 
 
 
      36. Details:
        37. 
 
 
@@ -570,7 +648,7 @@ del {background-color:#FFA0A0}
 
      37. 587 issues total, up by 13.
        38. 
 
 
      38. Details:
        39. 
@@ -587,7 +665,7 @@ del {background-color:#FFA0A0}
 
      39. Details:
        40. 
 
      40. Details:
        41. 
@@ -618,7 +696,7 @@ del {background-color:#FFA0A0}
 
      41. 535 issues total.
        42. 
 
 
      42. Details:
        43. 
 
 
@@ -627,7 +705,7 @@ del {background-color:#FFA0A0}
 Added new issues 526-528.
 Moved issues 280, 461, 464, 465, 467, 468, 474, 496 from Ready to WP as per the vote from Mont Tremblant.
 Moved issues 247, 294, 342, 362, 369, 371, 376, 384, 475, 478, 495, 497 from Review to Ready.
-Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open.
+Moved issues 498, 504, 506, 509, 510, 511, 512, 513, 514 from New to Open.
 Moved issues 505, 507, 508, 519 from New to Ready.
 Moved issue 500 from New to NAD.
 Moved issue 518 from New to Review.
@@ -639,7 +717,7 @@ Added new issues 498-503.
+Added new issues 498-503.
 
 
      43. R36: 
 2005-04 post-Lillehammer mailing. All issues in "ready" status except
@@ -663,7 +741,7 @@ new issues 463-478.
+new issues 463-478.
 
        44. 
 
      44. R30: 
 Post-Sydney mailing: reflects decisions made at the Sydney meeting.
@@ -678,7 +756,7 @@ Post-Kona mailing: reflects decisions made at the Kona meeting.
 Added new issues 432-440.
 
        45. 
 
      45. R27: 
-Pre-Kona mailing.  Added new issues 404-431.
+Pre-Kona mailing.  Added new issues 404-431.
 
        46. 
 
      46. R26: 
 Post-Oxford mailing: reflects decisions made at the Oxford meeting.
@@ -1302,7 +1380,7 @@ supporting to the proposed resolution.
        
 
 
        
 
        11. Bitset minor problems
        
-
        Section: 20.3.6 [template.bitset] Status: TC1
+
        Section: 20.3.7 [template.bitset] Status: TC1
  Submitter: Matt Austern Opened: 1998-01-22  Last modified: 2008-09-26
        
 
        View other active issues in [template.bitset].
        
 
        View all other issues in [template.bitset].
        
@@ -1323,7 +1401,7 @@ go in the Effects clause.
        
 
        Proposed resolution:
        
 
        ITEMS 1 AND 2:
        
 
        
-In the bitset synopsis (20.3.6 [template.bitset]), 
+In the bitset synopsis (20.3.7 [template.bitset]), 
 replace the member function 
        
 
        
     reference operator[](size_t pos);
        
@@ -1333,7 +1411,7 @@ with the two member functions
        
     bool operator[](size_t pos) const; 
        
     reference operator[](size_t pos); 
        
 
        
-Add the following text at the end of 20.3.6.2 [bitset.members], 
+Add the following text at the end of 20.3.7.2 [bitset.members], 
 immediately after paragraph 45:
        
 
 
        
@@ -2251,6 +2329,7 @@ string_type s = val ? np.truename() : np.falsename(); 
      
 
      35. No manipulator unitbuf in synopsis
      
 
      Section: 27.5 [iostreams.base] Status: TC1
  Submitter: Nathan Myers Opened: 1998-08-06  Last modified: 2008-09-26
      
+
      View all other issues in [iostreams.base].
      
 
      View all issues with TC1 status.
      
 
      Discussion:
      
 
      In 27.5.5.1 [fmtflags.manip], we have a definition for a manipulator
@@ -2811,13 +2890,13 @@ change uses of == and != to use the traits members instead. 
      
 
 
      
 
      46. Minor Annex D errors
      
-
      Section: D.7 [depr.str.strstreams] Status: TC1
+
      Section: D.8 [depr.str.strstreams] Status: TC1
  Submitter: Brendan Kehoe Opened: 1998-06-01  Last modified: 2008-09-26
      
 
      View all issues with TC1 status.
      
 
      Discussion:
      See lib-6522 and edit-814.
      
 
 
      Proposed resolution:
      
-
      Change D.7.1 [depr.strstreambuf] (since streambuf is a typedef of
+
      Change D.8.1 [depr.strstreambuf] (since streambuf is a typedef of
 basic_streambuf<char>) from:
      
 
 
               virtual streambuf<char>* setbuf(char* s, streamsize n);
      
@@ -2826,7 +2905,7 @@ basic_streambuf<char>) from:
      
 
 
               virtual streambuf* setbuf(char* s, streamsize n);
      
 
-
      In D.7.4 [depr.strstream] insert the semicolon now missing after
+
      In D.8.4 [depr.strstream] insert the semicolon now missing after
 int_type:
      
 
 
           namespace std {
@@ -3199,7 +3278,7 @@ stream position" should not be changed:
      
 
      
   
      27.8.1.4 [stringbuf.virtuals], paragraph 14
      
   27.9.1.5 [filebuf.virtuals], paragraph 14
      
-  D.7.1.3 [depr.strstreambuf.virtuals], paragraph 17
+  D.8.1.3 [depr.strstreambuf.virtuals], paragraph 17
   
      
 
      
 
@@ -3228,11 +3307,11 @@ returns an invalid stream position (_lib.iostreams.definitions_)"
 to "Otherwise returns pos_type(off_type(-1))"
 
      
 
-
      In D.7.1.3 [depr.strstreambuf.virtuals], paragraph 15, change "the object
+
      In D.8.1.3 [depr.strstreambuf.virtuals], paragraph 15, change "the object
 stores an invalid stream position" to "the return value is
 pos_type(off_type(-1))" 
      
 
-
      In D.7.1.3 [depr.strstreambuf.virtuals], paragraph 18, change "the object
+
      In D.8.1.3 [depr.strstreambuf.virtuals], paragraph 18, change "the object
 stores an invalid stream position" to "the return value is
 pos_type(off_type(-1))"
      
 
@@ -3788,7 +3867,7 @@ elaboration of the first. 
      
 
 
      
 
      66. Strstreambuf::setbuf
      
-
      Section: D.7.1.3 [depr.strstreambuf.virtuals] Status: TC1
+
      Section: D.8.1.3 [depr.strstreambuf.virtuals] Status: TC1
  Submitter: Matt Austern Opened: 1998-08-18  Last modified: 2008-09-26
      
 
      View all other issues in [depr.strstreambuf.virtuals].
      
 
      View all issues with TC1 status.
      
@@ -3801,7 +3880,7 @@ strstreambuf. 
      
 
 
 
      Proposed resolution:
      
-
      D.7.1.3 [depr.strstreambuf.virtuals], paragraph 19, replace the setbuf effects
+
      D.8.1.3 [depr.strstreambuf.virtuals], paragraph 19, replace the setbuf effects
 clause which currently says "Performs an operation that is
 defined separately for each class derived from strstreambuf"
 with:
      
@@ -3857,7 +3936,6 @@ item from:
      
 
      69. Must elements of a vector be contiguous?
      
 
      Section: 23.3.6 [vector] Status: TC1
  Submitter: Andrew Koenig Opened: 1998-07-29  Last modified: 2008-09-26
      
-
      View other active issues in [vector].
      
 
      View all other issues in [vector].
      
 
      View all issues with TC1 status.
      
 
      Discussion:
      
@@ -3892,7 +3970,7 @@ directly defined in the standard.  Discussion included:
      
     already used for valarray (26.6.2.3 [valarray.access]).
      3. 
   
    3. There is no need to explicitly consider a user-defined operator& 
     because elements must be copyconstructible (23.2 [container.requirements] para 3) 
-    and copyconstructible (X [utility.arg.requirements]) specifies
+    and copyconstructible (20.2.1 [utility.arg.requirements]) specifies
     requirements for operator&.
      4. 
   
    4. There is no issue of one-past-the-end because of language rules.
      5. 
 
@@ -4498,12 +4576,12 @@ objects by algorithms is unspecified".  Consider placing in
 
 
      
 
      98. Input iterator requirements are badly written
      
-
      Section: 24.2.2 [input.iterators] Status: CD1
+
      Section: 24.2.1 [input.iterators] Status: CD1
  Submitter: AFNOR Opened: 1998-10-07  Last modified: 2008-09-26
      
 
      View all other issues in [input.iterators].
      
 
      View all issues with CD1 status.
      
 
      Discussion:
      
-
      Table 72 in 24.2.2 [input.iterators] specifies semantics for
+
      Table 72 in 24.2.1 [input.iterators] specifies semantics for
 *r++ of:
      
 
 
         { T tmp = *r; ++r; return tmp; }
      
@@ -4522,7 +4600,7 @@ problem.
      
 
 
 
      Proposed resolution:
      
-
      In Table 72 in 24.2.2 [input.iterators], change the return type
+
      In Table 72 in 24.2.1 [input.iterators], change the return type
 for *r++ from T to "convertible to T".
      
 
 
@@ -4554,6 +4632,7 @@ for *r++ from T to "convertible to T".
      
 
      103. set::iterator is required to be modifiable, but this allows modification of keys
      
 
      Section: 23.2.4 [associative.reqmts] Status: CD1
  Submitter: AFNOR Opened: 1998-10-07  Last modified: 2008-09-26
      
+
      View other active issues in [associative.reqmts].
      
 
      View all other issues in [associative.reqmts].
      
 
      View all issues with CD1 status.
      
 
      Discussion:
      
@@ -4736,7 +4815,7 @@ returned by what().
 
 
      
 
      109. Missing binders for non-const sequence elements
      
-
      Section: D.8 [depr.lib.binders] Status: CD1
+
      Section: D.9 [depr.lib.binders] Status: CD1
  Submitter: Bjarne Stroustrup Opened: 1998-10-07  Last modified: 2008-09-26
      
 
      View all other issues in [depr.lib.binders].
      
 
      View all issues with CD1 status.
      
@@ -4817,7 +4896,7 @@ public:
 
      Howard believes there is a flaw in this resolution.
 See c++std-lib-9127.  We may need to reopen this issue.
      
 
-
      In D.8 [depr.lib.binders] in the declaration of binder1st after:
      
+
      In D.9 [depr.lib.binders] in the declaration of binder1st after:
      
 
      
   
      typename Operation::result_type
      
    operator()(const typename Operation::second_argument_type& x) const;
      
@@ -4827,7 +4906,7 @@ See c++std-lib-9127.  We may need to reopen this issue.
      
   
      typename Operation::result_type
      
    operator()(typename Operation::second_argument_type& x) const;
      
 
      
-
      In D.8 [depr.lib.binders] in the declaration of binder2nd after:
      
+
      In D.9 [depr.lib.binders] in the declaration of binder2nd after:
      
 
      
   
      typename Operation::result_type
      
    operator()(const typename Operation::first_argument_type& x) const;
      
@@ -4953,7 +5032,7 @@ likely to fail.
      
 
 
      
 
      115. Typo in strstream constructors
      
-
      Section: D.7.4.1 [depr.strstream.cons] Status: TC1
+
      Section: D.8.4.1 [depr.strstream.cons] Status: TC1
  Submitter: Steve Clamage Opened: 1998-11-02  Last modified: 2008-09-26
      
 
      View all issues with TC1 status.
      
 
      Discussion:
      
@@ -4975,7 +5054,7 @@ the append bit is set.
      
 
 
 
      Proposed resolution:
      
-
      In D.7.3.1 [depr.ostrstream.cons] paragraph 2 and D.7.4.1 [depr.strstream.cons]
+
      In D.8.3.1 [depr.ostrstream.cons] paragraph 2 and D.8.4.1 [depr.strstream.cons]
 paragraph 2, change the first condition to (mode&app)==0
 and the second condition to (mode&app)!=0.
      
 
@@ -5176,12 +5255,12 @@ operator>>(int& val);
    
 
 
    
 
    119. Should virtual functions be allowed to strengthen the exception specification?
    
-
    Section: 17.6.4.10 [res.on.exception.handling] Status: TC1
+
    Section: 17.6.4.11 [res.on.exception.handling] Status: TC1
  Submitter: Judy Ward Opened: 1998-12-15  Last modified: 2008-09-26
    
 
    View all other issues in [res.on.exception.handling].
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
-
    Section 17.6.4.10 [res.on.exception.handling] states: 
    
+
    Section 17.6.4.11 [res.on.exception.handling] states: 
    
 
 
    "An implementation may strengthen the exception-specification
 for a function by removing listed exceptions." 
    
@@ -5205,7 +5284,7 @@ public:
 
 
 
    Proposed resolution:
    
-
    Change Section 17.6.4.10 [res.on.exception.handling] from:
    
+
    Change Section 17.6.4.11 [res.on.exception.handling] from:
    
 
 
         "may strengthen the
 exception-specification for a function"
    
@@ -5574,7 +5653,7 @@ latter appears to be correct. 
    
 
 
    
 
    127. auto_ptr<> conversion issues
    
-
    Section: D.9.1 [auto.ptr] Status: TC1
+
    Section: D.10.1 [auto.ptr] Status: TC1
  Submitter: Greg Colvin Opened: 1999-02-17  Last modified: 2008-09-26
    
 
    View all other issues in [auto.ptr].
    
 
    View all issues with TC1 status.
    
@@ -5688,6 +5767,7 @@ stream state in case of failure.
    
 
    130. Return type of container::erase(iterator) differs for associative containers
    
 
    Section: 23.2.4 [associative.reqmts], 23.2.3 [sequence.reqmts] Status: CD1
  Submitter: Andrew Koenig Opened: 1999-03-02  Last modified: 2009-05-01
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Duplicate of: 451
    
@@ -5979,6 +6059,7 @@ in the standard.
    
 
    139. Optional sequence operation table description unclear
    
 
    Section: 23.2.3 [sequence.reqmts] Status: TC1
  Submitter: Andrew Koenig Opened: 1999-03-30  Last modified: 2008-09-26
    
+
    View other active issues in [sequence.reqmts].
    
 
    View all other issues in [sequence.reqmts].
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -6042,7 +6123,7 @@ proposed resolution.]
    
 
 
    
 
    142. lexicographical_compare complexity wrong
    
-
    Section: 25.5.8 [alg.lex.comparison] Status: TC1
+
    Section: 25.4.8 [alg.lex.comparison] Status: TC1
  Submitter: Howard Hinnant Opened: 1999-06-20  Last modified: 2008-09-26
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -6060,7 +6141,7 @@ right! (and Matt states this complexity in his book)
    
 
 
 
    Proposed resolution:
    
-
    Change 25.5.8 [alg.lex.comparison] complexity to:
    
+
    Change 25.4.8 [alg.lex.comparison] complexity to:
    
     
    
     At most 2*min((last1 - first1), (last2 - first2))
     applications of the corresponding comparison.
@@ -6312,9 +6393,437 @@ two places:
    
 
 
 
+
    
+
    149. Insert should return iterator to first element inserted
    
+
    Section: 23.2.3 [sequence.reqmts] Status: WP
+ Submitter: Andrew Koenig Opened: 1999-06-28  Last modified: 2009-10-26
    
+
    View other active issues in [sequence.reqmts].
    
+
    View all other issues in [sequence.reqmts].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    Suppose that c and c1 are sequential containers and i is an
+iterator that refers to an element of c.  Then I can insert a copy of
+c1's elements into c ahead of element i by executing 
    
+
+
    
+
+
    c.insert(i, c1.begin(), c1.end());
    
+
+
    
+
+
    If c is a vector, it is fairly easy for me to find out where the
+newly inserted elements are, even though i is now invalid: 
    
+
+
    
+
+
    size_t i_loc = i - c.begin();
+c.insert(i, c1.begin(), c1.end());
    
+
+
    
+
+
    and now the first inserted element is at c.begin()+i_loc and one
+past the last is at c.begin()+i_loc+c1.size().
    
+
    
+But what if c is a list? I can still find the location of one past the
+last inserted element, because i is still valid. To find the location
+of the first inserted element, though, I must execute something like 
    
+
+
    
+
+
    for (size_t n = c1.size(); n; --n)
+   --i;
    
+
+
    
+
+
    because i is now no longer a random-access iterator.
    
+
    
+Alternatively, I might write something like 
    
+
+
    
+
+
    bool first = i == c.begin();
+list<T>::iterator j = i;
+if (!first) --j;
+c.insert(i, c1.begin(), c1.end());
+if (first)
+   j = c.begin();
+else
+   ++j;
    
+
+
    
+
+
    which, although wretched, requires less overhead.
    
+
    
+But I think the right solution is to change the definition of insert
+so that instead of returning void, it returns an iterator that refers
+to the first element inserted, if any, and otherwise is a copy of its
+first argument.  
    
+
+
    [
+Summit:
+]
    
+
+
+
    
+Reopened by Alisdair.
+
    
+
+
    [
+Post Summit Alisdair adds:
+]
    
+
+
+
    
+
    
+In addition to the original rationale for C++03, this change also gives a
+consistent interface for all container insert operations i.e. they all
+return an iterator to the (first) inserted item.
+
    
+
+
    
+Proposed wording provided.
+
    
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Q: why isn't this change also proposed for associative containers?
+
    
+
+
    
+A: The returned iterator wouldn't necessarily point to a contiguous range.
+
    
+
+
    
+Moved to Ready.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+ Table 83
+change return type from void to iterator for the following rows:
+
    
+
+
    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
    Table 83 -- Sequence container requirements (in addition to container)
    ExpressionReturn typeAssertion/note pre-/post-condition
    
+a.insert(p,n,t)
+
+void iterator
+
+Inserts n copies of t before p.
+
    
+a.insert(p,i,j)
+
+void iterator
+
+Each iterator in the range [i,j) shall be 
+dereferenced exactly once. 
+pre: i and j are not iterators into a. 
+Inserts copies of elements in [i, j) before p
+
    
+a.insert(p,il)
+
+void iterator
+
+a.insert(p, il.begin(), il.end()).
+
    
+
    
+
+
    
+Add after p6 23.2.3 [sequence.reqmts]:
+
    
+
+
    
+
    -6- ...
    
+
+
    
+The iterator returned from a.insert(p,n,t) points to the copy of the
+first element inserted into a, or p if n == 0.
+
    
+
+
    
+The iterator returned from a.insert(p,i,j) points to the copy of the
+first element inserted into a, or p if i == j.
+
    
+
+
    
+The iterator returned from a.insert(p,il) points to the copy of the
+first element inserted into a, or p if il is empty.
+
    
+
+
    
+
+
    
+p2 23.3.2 [deque] Update class definition, change return type
+from void to iterator:
+
    
+
+
    void iterator insert(const_iterator position, size_type n, const T& x);
+template <class InputIterator>
+  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+  void iterator insert(const_iterator position, initializer_list<T>);
+
    
+
+
    
+23.3.2.3 [deque.modifiers] change return type from void to iterator on following declarations:
+
    
+
+
      void iterator insert(const_iterator position, size_type n, const T& x);
+template <class InputIterator>
+  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+
    
+
+
    
+Add the following (missing) declaration
+
    
+
+
    iterator insert(const_iterator position, initializer_list<T>);
+
    
+
+
    
+23.3.3 [forwardlist] Update class definition, change return type
+from void to iterator:
+
    
+
+
    void iterator insert_after(const_iterator position, initializer_list<T> il);
+void iterator insert_after(const_iterator position, size_type n, const T& x);
+template <class InputIterator>
+  void iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
+
    
+
+
    
+p8 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator:
+
    
+
+
    void iterator insert_after(const_iterator position, size_type n, const T& x);
+
    
+
+
    
+Add paragraph:
+
    
+
+
    
+Returns: position.
+
    
+
+
    
+p10 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator:
+
    
+
+
    template <class InputIterator>
+  void iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
+
    
+
+
    
+Add paragraph:
+
    
+
+
    
+Returns: position.
+
    
+
+
    
+p12 23.3.3.4 [forwardlist.modifiers] change return type from void to iterator on following declarations:
+
    
+
+
    void iterator insert_after(const_iterator position, initializer_list<T> il);
+
    
+
+
    
+change return type from void to iterator on following declarations:
+
    
+
+
    
+p2 23.3.4 [list] Update class definition, change return type from void to iterator:
+
    
+
+
    void iterator insert(const_iterator position, size_type n, const T& x);
+
+template <class InputIterator>
+void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+
+void iterator insert(const_iterator position, initializer_list<T>);
+
    
+
+
    
+23.3.4.3 [list.modifiers] change return type from void to iterator on following declarations:
+
    
+
+
    void iterator insert(const_iterator position, size_type n, const T& x);
+
+template <class InputIterator>
+  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+
    
+
+
    
+Add the following (missing) declaration
+
    
+
+
    iterator insert(const_iterator position, initializer_list<T>);
+
    
+
+
    
+p2 23.3.6 [vector]
+
    
+
+
    
+Update class definition, change return type from void to iterator:
+
    
+
+
    void iterator insert(const_iterator position, T&& x);
+
+void iterator insert(const_iterator position, size_type n, const T& x);
+
+template <class InputIterator>
+  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+
+void iterator insert(const_iterator position, initializer_list<T>);
+
    
+
+
    
+23.3.6.4 [vector.modifiers] change return type from void to iterator on following declarations:
+
    
+
+
    void iterator insert(const_iterator position, size_type n, const T& x);
+
+template <class InputIterator>
+  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+
    
+
+
    
+Add the following (missing) declaration
+
    
+
+
    iterator insert(const_iterator position, initializer_list<T>);
+
    
+
+
+
    
+p1 23.3.7 [vector.bool] Update class definition, change return type from void to iterator:
+
    
+
+
    void iterator insert (const_iterator position, size_type n, const bool& x);
+
+template <class InputIterator>
+  void iterator insert(const_iterator position, InputIterator first, InputIterator last);
+
+  void iterator insert(const_iterator position, initializer_list<bool> il);
+
    
+
+
    
+p5 21.4 [basic.string] Update class definition, change return type from void to iterator:
+
    
+
+
    void iterator insert(const_iterator p, size_type n, charT c);
+
+template<class InputIterator>
+  void iterator insert(const_iterator p, InputIterator first, InputIterator last);
+
+void iterator insert(const_iterator p, initializer_list<charT>);
+
    
+
+
    
+p13 21.4.6.4 [string::insert] change return type from void to iterator:
+
    
+
+
    void iterator insert(const_iterator p, size_type n, charT c);
+
    
+
+
    
+Add paragraph:
+
    
+
+
    
+Returns: an iterator which refers to the copy of the first inserted
+character, or p if n == 0.
+
    
+
+
    
+p15 21.4.6.4 [string::insert] change return type from void to iterator:
+
    
+
+
    template<class InputIterator>
+  void iterator insert(const_iterator p, InputIterator first, InputIterator last);
+
    
+
+
    
+Add paragraph:
+
    
+
+
    
+Returns: an iterator which refers to the copy of the first inserted
+character, or p if first == last.
+
    
+
+
    
+p17 21.4.6.4 [string::insert] change return type from void to iterator:
+
    
+
+
    void iterator insert(const_iterator p, initializer_list<charT> il);
+
    
+
+
    
+Add paragraph:
+
    
+
+
    
+Returns: an iterator which refers to the copy of the first inserted
+character, or p if il is empty.
+
    
+
+
+
+
    Rationale:
    
+
+
    [
+The following was the C++98/03 rationale and does not necessarily apply to the
+proposed resolution in the C++0X time frame:
+]
    
+
+
+
    
+
    The LWG believes this was an intentional design decision and so is
+not a defect. It may be worth revisiting for the next standard.
    
+
    
+
+
+
+
 
    
 
    150. Find_first_of says integer instead of iterator 
    
-
    Section: 25.3.7 [alg.find.first.of] Status: TC1
+
    Section: 25.2.7 [alg.find.first.of] Status: TC1
  Submitter: Matt McClure Opened: 1999-06-30  Last modified: 2008-09-26
    
 
    View all other issues in [alg.find.first.of].
    
 
    View all issues with TC1 status.
    
@@ -6322,7 +6831,7 @@ two places:
    
 
 
 
    Proposed resolution:
    
-
    Change 25.3.7 [alg.find.first.of] paragraph 2 from:
    
+
    Change 25.2.7 [alg.find.first.of] paragraph 2 from:
    
 
 
    
 
    Returns: The first iterator i in the range [first1, last1) such
@@ -6343,6 +6852,7 @@ that for some iterator j in the range [first2, last2) ...
    
 
    151. Can't currently clear() empty container
    
 
    Section: 23.2.3 [sequence.reqmts] Status: TC1
  Submitter: Ed Brey Opened: 1999-06-21  Last modified: 2008-09-26
    
+
    View other active issues in [sequence.reqmts].
    
 
    View all other issues in [sequence.reqmts].
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -7036,7 +7546,7 @@ as described in issue 174. Typo: OFF_T vs. POS_T
-
    Section: D.6 [depr.ios.members] Status: TC1
+
    Section: D.7 [depr.ios.members] Status: TC1
  Submitter: Dietmar Kühl Opened: 1999-07-23  Last modified: 2008-09-26
    
 
    View all other issues in [depr.ios.members].
    
 
    View all issues with TC1 status.
    
@@ -7047,7 +7557,7 @@ paragraph 6 the streampos gets the type POS_T
    
 
 
 
    Proposed resolution:
    
-
    Change D.6 [depr.ios.members] paragraph 1 from "typedef
+
    Change D.7 [depr.ios.members] paragraph 1 from "typedef
 OFF_T streampos;" to "typedef POS_T
 streampos;"
    
 
@@ -7056,7 +7566,7 @@ streampos;"
    
 
 
    
 
    175. Ambiguity for basic_streambuf::pubseekpos() and a few other functions.
    
-
    Section: D.6 [depr.ios.members] Status: TC1
+
    Section: D.7 [depr.ios.members] Status: TC1
  Submitter: Dietmar Kühl Opened: 1999-07-23  Last modified: 2008-09-26
    
 
    View all other issues in [depr.ios.members].
    
 
    View all issues with TC1 status.
    
@@ -7075,7 +7585,7 @@ argument is not specified.
    
 
 
 
    Proposed resolution:
    
-
    In D.6 [depr.ios.members] paragraph 8, remove the default arguments for
+
    In D.7 [depr.ios.members] paragraph 8, remove the default arguments for
 basic_streambuf::pubseekpos(),
 basic_ifstream::open(), and
 basic_ofstream::open().
    
@@ -7085,7 +7595,7 @@ argument is not specified.
    
 
 
    
 
    176. exceptions() in ios_base...?
    
-
    Section: D.6 [depr.ios.members] Status: TC1
+
    Section: D.7 [depr.ios.members] Status: TC1
  Submitter: Dietmar Kühl Opened: 1999-07-23  Last modified: 2008-09-26
    
 
    View all other issues in [depr.ios.members].
    
 
    View all issues with TC1 status.
    
@@ -7099,7 +7609,7 @@ in clause 27 [input.output]."
    
 
 
 
    Proposed resolution:
    
-
    In D.6 [depr.ios.members] paragraph 8, move the declaration of the
+
    In D.7 [depr.ios.members] paragraph 8, move the declaration of the
 function exceptions()into class basic_ios.
    
 
 
@@ -7365,7 +7875,7 @@ standard. Also see issue 181. make_pair() unintended behavior
-
    Section: 20.3.3 [pairs] Status: TC1
+
    Section: 20.3.4 [pairs] Status: TC1
  Submitter: Andrew Koenig Opened: 1999-08-03  Last modified: 2008-09-26
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
@@ -7392,7 +7902,7 @@ declaration of make_pair():
    
 
    
   
    template <class T1, class T2> pair<T1,T2> make_pair(T1, T2);
    
 
    
-
      In 20.3.3 [pairs] paragraph 7 and the line before, change:
    
+
      In 20.3.4 [pairs] paragraph 7 and the line before, change:
    
 
    
 
    template <class T1, class T2>
 pair<T1, T2> make_pair(const T1& x, const T2& y);
    
@@ -7918,12 +8428,12 @@ not required elsewhere.
    
 
 
    
 
    186. bitset::set() second parameter should be bool
    
-
    Section: 20.3.6.2 [bitset.members] Status: CD1
+
    Section: 20.3.7.2 [bitset.members] Status: CD1
  Submitter: Darin Adler Opened: 1999-08-13  Last modified: 2008-09-26
    
 
    View all other issues in [bitset.members].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
-
    In section 20.3.6.2 [bitset.members], paragraph 13 defines the
+
    In section 20.3.7.2 [bitset.members], paragraph 13 defines the
 bitset::set operation to take a second parameter of type int. The
 function tests whether this value is non-zero to determine whether to
 set the bit to true or false. The type of this second parameter should
@@ -7935,7 +8445,7 @@ translating 0 to false and any non-zero value to true.
    
 
 
 
    Proposed resolution:
    
-
    In 20.3.6 [template.bitset] Para 1 Replace:
    
+
    In 20.3.7 [template.bitset] Para 1 Replace:
    
 
    
 
    bitset<N>& set(size_t pos, int val = true ); 
    
 
    
@@ -7943,7 +8453,7 @@ translating 0 to false and any non-zero value to true.
    
 
    
   
    bitset<N>& set(size_t pos, bool val = true );
    
 
    
-
    In 20.3.6.2 [bitset.members] Para 12(.5) Replace:
    
+
    In 20.3.7.2 [bitset.members] Para 12(.5) Replace:
    
 
    
   
    bitset<N>& set(size_t pos, int val = 1 );
    
 
    
@@ -7972,7 +8482,7 @@ nonvirtual member of a standard library class.
    
 
 
    
 
    187. iter_swap underspecified
    
-
    Section: 25.4.3 [alg.swap] Status: CD1
+
    Section: 25.3.3 [alg.swap] Status: CD1
  Submitter: Andrew Koenig Opened: 1999-08-14  Last modified: 2008-09-26
    
 
    View all other issues in [alg.swap].
    
 
    View all issues with CD1 status.
    
@@ -8070,7 +8580,7 @@ correct the statement in 27.4.2.2
    
 
 
    
 
    193. Heap operations description incorrect
    
-
    Section: 25.5.6 [alg.heap.operations] Status: TC1
+
    Section: 25.4.6 [alg.heap.operations] Status: TC1
  Submitter: Markus Mauhart Opened: 1999-09-24  Last modified: 2008-09-26
    
 
    View all issues with TC1 status.
    
 
    Duplicate of: 216
    
@@ -8095,7 +8605,7 @@ priority AND time).
    
 
 
 
    Proposed resolution:
    
-
    Change 25.5.6 [alg.heap.operations] property (1) from:
    
+
    Change 25.4.6 [alg.heap.operations] property (1) from:
    
 
    
   
    (1) *a is the largest element
    
 
    
@@ -8169,9 +8679,8 @@ returns traits::eof(), the function calls
 
 
    
 
    198. Validity of pointers and references unspecified after iterator destruction
    
-
    Section: 24.2 [iterator.concepts] Status: CD1
+
    Section: X [iterator.concepts] Status: CD1
  Submitter: Beman Dawes Opened: 1999-11-03  Last modified: 2008-09-30
    
-
    View other active issues in [iterator.concepts].
    
 
    View all other issues in [iterator.concepts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -8221,14 +8730,14 @@ elements of containers.
    
 
 
    The standard itself assumes that pointers and references obtained
 from an iterator are still valid after iterator destruction or
-change. The definition of reverse_iterator::operator*(), 24.5.1.2.3 [reverse.iter.conv], which returns a reference, defines
+change. The definition of reverse_iterator::operator*(), 24.5.1.3.3 [reverse.iter.conv], which returns a reference, defines
 effects:
    
 
 
    
   
    Iterator tmp = current;
 return *--tmp;
    
 
    
-
    The definition of reverse_iterator::operator->(), 24.5.1.2.4
+
    The definition of reverse_iterator::operator->(), 24.5.1.3.4
 [reverse.iter.op.star], which returns a pointer, defines effects:
    
 
    
   
    return &(operator*());
    
@@ -8242,13 +8751,13 @@ implementation.
    
 
 
 
    Proposed resolution:
    
-
    Add a new paragraph to 24.2 [iterator.concepts]:
    
+
    Add a new paragraph to X [iterator.concepts]:
    
 
    
 Destruction of an iterator may invalidate pointers and references
 previously obtained from that iterator.
 
    
 
-
    Replace paragraph 1 of 24.5.1.2.3 [reverse.iter.conv] with:
    
+
    Replace paragraph 1 of 24.5.1.3.3 [reverse.iter.conv] with:
    
 
 
    
 
    Effects:
    
@@ -8261,7 +8770,7 @@ previously obtained from that iterator.
 [Note: This operation must use an auxiliary member variable,
 rather than a temporary variable, to avoid returning a reference that
 persists beyond the lifetime of its associated iterator.  (See
-24.2 [iterator.concepts].)  The name of this member variable is shown for
+X [iterator.concepts].)  The name of this member variable is shown for
 exposition only.  --end note]
 
    
 
    
@@ -8311,9 +8820,8 @@ predefined iterators are as strong as users expect.
    
 
 
    
 
    199. What does allocate(0) return?
    
-
    Section: X [allocator.requirements] Status: TC1
+
    Section: 20.2.2 [allocator.requirements] Status: TC1
  Submitter: Matt Austern Opened: 1999-11-19  Last modified: 2008-09-26
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -8347,7 +8855,7 @@ would be over-specification to mandate the return value.
 
 
    
 
    200. Forward iterator requirements don't allow constant iterators
    
-
    Section: 24.2.4 [forward.iterators] Status: CD1
+
    Section: 24.2.3 [forward.iterators] Status: CD1
  Submitter: Matt Austern Opened: 1999-11-19  Last modified: 2008-09-26
    
 
    View all other issues in [forward.iterators].
    
 
    View all issues with CD1 status.
    
@@ -8469,7 +8977,7 @@ which do not.
 
 
    
 
    202. unique() effects unclear when predicate not an equivalence relation
    
-
    Section: 25.4.9 [alg.unique] Status: CD1
+
    Section: 25.3.9 [alg.unique] Status: CD1
  Submitter: Andrew Koenig Opened: 2000-01-13  Last modified: 2008-09-26
    
 
    View all other issues in [alg.unique].
    
 
    View all issues with CD1 status.
    
@@ -8542,7 +9050,7 @@ In fact, the SGI implementation of unique() does neither: It yields 1,
 
 
 
    Proposed resolution:
    
-
    Change 25.4.9 [alg.unique] paragraph 1 to:
    
+
    Change 25.3.9 [alg.unique] paragraph 1 to:
    
 
    
 For a nonempty range, eliminates all but the first element from every
 consecutive group of equivalent elements referred to by the iterator
@@ -8577,7 +9085,7 @@ require another round of review.]
    
 
 
    Rationale:
    
 
    The LWG also considered an alternative resolution: change 
-25.4.9 [alg.unique] paragraph 1 to:
    
+25.3.9 [alg.unique] paragraph 1 to:
    
 
 
    
 For a nonempty range, eliminates all but the first element from every
@@ -8903,9 +9411,8 @@ his customers.
 
 
    
 
    208. Unnecessary restriction on past-the-end iterators
    
-
    Section: 24.2 [iterator.concepts] Status: TC1
+
    Section: X [iterator.concepts] Status: TC1
  Submitter: Stephen Cleary Opened: 2000-02-02  Last modified: 2008-09-30
    
-
    View other active issues in [iterator.concepts].
    
 
    View all other issues in [iterator.concepts].
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -8922,7 +9429,7 @@ iterators obtained from different (generic) containers being not equal.
    
 
 
 
    Proposed resolution:
    
-
    Change 24.2 [iterator.concepts] paragraph 5, the last sentence, from:
    
+
    Change X [iterator.concepts] paragraph 5, the last sentence, from:
    
 
    
 
    Dereferenceable and past-the-end values are always non-singular.
    
 
    
@@ -9055,7 +9562,7 @@ is.setstate(ios::failbit) which may throw ios_base::failure
 
 
    
 
    212. Empty range behavior unclear for several algorithms
    
-
    Section: 25.5.7 [alg.min.max] Status: TC1
+
    Section: 25.4.7 [alg.min.max] Status: TC1
  Submitter: Nico Josuttis Opened: 2000-02-26  Last modified: 2008-09-26
    
 
    View all other issues in [alg.min.max].
    
 
    View all issues with TC1 status.
    
@@ -9067,7 +9574,7 @@ next_permutation(), and prev_permutation().
    
 
 
 
    Proposed resolution:
    
-
    In 25.5.7 [alg.min.max] - Minimum and maximum, paragraphs 7 and
+
    In 25.4.7 [alg.min.max] - Minimum and maximum, paragraphs 7 and
 9, append: Returns last if first==last.
    
 
 
@@ -9331,7 +9838,7 @@ footnote.
    
 
 
    
 
    223. reverse algorithm should use iter_swap rather than swap
    
-
    Section: 25.4.10 [alg.reverse] Status: TC1
+
    Section: 25.3.10 [alg.reverse] Status: TC1
  Submitter: Dave Abrahams Opened: 2000-03-21  Last modified: 2008-09-26
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -9339,7 +9846,7 @@ footnote.
    
 
 
 
    Proposed resolution:
    
-
    In 25.4.10 [alg.reverse], replace:
    
+
    In 25.3.10 [alg.reverse], replace:
    
   
    
   Effects: For each non-negative integer i <= (last - first)/2, 
   applies swap to all pairs of iterators first + i, (last - i) - 1.
@@ -9357,6 +9864,7 @@ footnote.
    
 
    224. clear() complexity for associative containers refers to undefined N
    
 
    Section: 23.2.4 [associative.reqmts] Status: TC1
  Submitter: Ed Brey Opened: 2000-03-23  Last modified: 2008-09-26
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with TC1 status.
    
 
    Discussion:
    
@@ -9705,7 +10213,7 @@ resolution is the one proposed by Howard.]
    
 
 
    
 
    227. std::swap() should require CopyConstructible or DefaultConstructible arguments
    
-
    Section: 25.4.3 [alg.swap] Status: TC1
+
    Section: 25.3.3 [alg.swap] Status: TC1
  Submitter: Dave Abrahams Opened: 2000-04-09  Last modified: 2008-09-26
    
 
    View all other issues in [alg.swap].
    
 
    View all issues with TC1 status.
    
@@ -10002,7 +10510,7 @@ Assignable"
 CopyConstructible and Assignable"
    
 
    
 
-
    In 24.2.3 [output.iterators] paragraph 1, change:
+
    In 24.2.2 [output.iterators] paragraph 1, change:
 
    
 
    
 
     A class or a built-in type X satisfies the requirements of an
@@ -10021,7 +10529,7 @@ Table 73:
 
    
 
 
    [Post-Tokyo: Beman Dawes submitted this issue at the request of
-the LWG.  He asks that the 25.4.5 [alg.replace] and 25.4.6 [alg.fill] changes be studied carefully, as it is not clear that
+the LWG.  He asks that the 25.3.5 [alg.replace] and 25.3.6 [alg.fill] changes be studied carefully, as it is not clear that
 CopyConstructible is really a requirement and may be
 overspecification.]
    
 
@@ -10184,6 +10692,7 @@ rationale.]
    
 
    233. Insertion hints in associative containers
    
 
    Section: 23.2.4 [associative.reqmts] Status: CD1
  Submitter: Andrew Koenig Opened: 2000-04-30  Last modified: 2008-09-26
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Duplicate of: 192, 246
    
@@ -10333,7 +10842,7 @@ logarithmic in general, but amortized constant if t is inserted right <
 
 
    
 
    234. Typos in allocator definition
    
-
    Section: 20.8.4.1 [allocator.members] Status: CD1
+
    Section: 20.8.8.1 [allocator.members] Status: CD1
  Submitter: Dietmar Kühl Opened: 2000-04-24  Last modified: 2008-09-26
    
 
    View all other issues in [allocator.members].
    
 
    View all issues with CD1 status.
    
@@ -10361,7 +10870,7 @@ should do.
    
 
 
 
    Proposed resolution:
    
-  
    In section 24.5.1.2.1 [reverse.iter.cons] add the following
+  
    In section 24.5.1.3.1 [reverse.iter.cons] add the following
   paragraph:
    
       
    
       
    reverse_iterator()
    
@@ -10405,6 +10914,7 @@ would have to be last - first.
    
 
    238. Contradictory results of stringbuf initialization.
    
 
    Section: 27.8.1.1 [stringbuf.cons] Status: CD1
  Submitter: Dietmar Kühl Opened: 2000-05-11  Last modified: 2008-09-26
    
+
    View all other issues in [stringbuf.cons].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    In 27.7.1.1 paragraph 4 the results of calling the constructor of
@@ -10440,7 +10950,7 @@ in the standard.
    
 
 
    
 
    239. Complexity of unique() and/or unique_copy incorrect
    
-
    Section: 25.4.9 [alg.unique] Status: CD1
+
    Section: 25.3.9 [alg.unique] Status: CD1
  Submitter: Angelika Langer Opened: 2000-05-15  Last modified: 2008-09-26
    
 
    View all other issues in [alg.unique].
    
 
    View all issues with CD1 status.
    
@@ -10473,7 +10983,7 @@ twice.
    
 
 
 
    Proposed resolution:
    
-
    Change both complexity sections in 25.4.9 [alg.unique] to:
    
+
    Change both complexity sections in 25.3.9 [alg.unique] to:
    
 
 
    Complexity: For nonempty ranges, exactly last - first - 1
 applications of the corresponding predicate.
    
@@ -10485,7 +10995,7 @@ applications of the corresponding predicate.
    
 
 
    
 
    240. Complexity of adjacent_find() is meaningless
    
-
    Section: 25.3.8 [alg.adjacent.find] Status: CD1
+
    Section: 25.2.8 [alg.adjacent.find] Status: CD1
  Submitter: Angelika Langer Opened: 2000-05-15  Last modified: 2008-09-26
    
 
    View all other issues in [alg.adjacent.find].
    
 
    View all issues with CD1 status.
    
@@ -10526,7 +11036,7 @@ an "as-if" specification.
    
 
 
 
    Proposed resolution:
    
-
    Change the complexity section in 25.3.8 [alg.adjacent.find] to:
    
+
    Change the complexity section in 25.2.8 [alg.adjacent.find] to:
    
 
    
 For a nonempty range, exactly min((i - first) + 1,
 (last - first) - 1) applications of the
@@ -10545,7 +11055,7 @@ bound.  The LWG preferred an exact count.]
    
 
 
    
 
    241. Does unique_copy() require CopyConstructible and Assignable?
    
-
    Section: 25.4.9 [alg.unique] Status: CD1
+
    Section: 25.3.9 [alg.unique] Status: CD1
  Submitter: Angelika Langer Opened: 2000-05-15  Last modified: 2008-09-26
    
 
    View all other issues in [alg.unique].
    
 
    View all issues with CD1 status.
    
@@ -10614,7 +11124,7 @@ minor as not to require re-review.
 
 
    
 
    242. Side effects of function objects
    
-
    Section: 25.4.4 [alg.transform], 26.5 [rand] Status: CD1
+
    Section: 25.3.4 [alg.transform], 26.5 [rand] Status: CD1
  Submitter: Angelika Langer Opened: 2000-05-15  Last modified: 2008-09-26
    
 
    View all other issues in [alg.transform].
    
 
    View all issues with CD1 status.
    
@@ -10972,6 +11482,7 @@ input facets.
    
 
    250. splicing invalidates iterators
    
 
    Section: 23.3.4.4 [list.ops] Status: CD1
  Submitter: Brian Parker  Opened: 2000-07-14  Last modified: 2008-09-26
    
+
    View other active issues in [list.ops].
    
 
    View all other issues in [list.ops].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -11749,9 +12260,8 @@ copyfmt_event.
 
 
    
 
    258. Missing allocator requirement
    
-
    Section: X [allocator.requirements] Status: CD1
+
    Section: 20.2.2 [allocator.requirements] Status: CD1
  Submitter: Matt Austern Opened: 2000-08-22  Last modified: 2008-09-26
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -12070,6 +12580,7 @@ Change the following sentence in 21.3 paragraph 5 from
 
    264. Associative container insert(i, j) complexity requirements are not feasible.
    
 
    Section: 23.2.4 [associative.reqmts] Status: CD1
  Submitter: John Potter Opened: 2000-09-07  Last modified: 2008-09-26
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Duplicate of: 102
    
@@ -12122,7 +12633,7 @@ linear in some special cases.
 
 
    
 
    265. std::pair::pair() effects overly restrictive
    
-
    Section: 20.3.3 [pairs] Status: CD1
+
    Section: 20.3.4 [pairs] Status: CD1
  Submitter: Martin Sebor Opened: 2000-09-11  Last modified: 2008-09-26
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
@@ -12188,8 +12699,8 @@ clause is missing).
 
    
 Remove the destructor from the class synopses of 
 bad_alloc (18.6.2.1 [bad.alloc]),
-bad_cast (18.7.3 [bad.cast]),
-bad_typeid (18.7.4 [bad.typeid]),
+bad_cast (18.7.2 [bad.cast]),
+bad_typeid (18.7.3 [bad.typeid]),
 and bad_exception (18.8.2.1 [bad.exception]).
 
    
 
@@ -12239,7 +12750,7 @@ are missing.
    
 
 
    
 
    270. Binary search requirements overly strict
    
-
    Section: 25.5.3 [alg.binary.search] Status: CD1
+
    Section: 25.4.3 [alg.binary.search] Status: CD1
  Submitter: Matt Austern Opened: 2000-10-18  Last modified: 2008-09-26
    
 
    View all other issues in [alg.binary.search].
    
 
    View all issues with CD1 status.
    
@@ -12584,9 +13095,8 @@ members, i.e., ios_base.
    
 
 
    
 
    274. a missing/impossible allocator requirement
    
-
    Section: X [allocator.requirements] Status: CD1
+
    Section: 20.2.2 [allocator.requirements] Status: CD1
  Submitter: Martin Sebor Opened: 2000-11-02  Last modified: 2008-09-26
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -12873,6 +13383,7 @@ implement vector::push_back in terms of
 
    278. What does iterator validity mean?
    
 
    Section: 23.3.4.4 [list.ops] Status: CD1
  Submitter: P.J. Plauger Opened: 2000-11-27  Last modified: 2008-09-30
    
+
    View other active issues in [list.ops].
    
 
    View all other issues in [list.ops].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -12905,7 +13416,7 @@ introduce separate terms for the two kinds of "validity."
 
 
 
    Proposed resolution:
    
-
    Add the following text to the end of section 24.2 [iterator.concepts],
+
    Add the following text to the end of section X [iterator.concepts],
 after paragraph 5:
    
 
    
 An invalid iterator is an iterator that may be
@@ -12996,7 +13507,7 @@ add/change the following declarations:
    
 
    
 
    
 Also make the addition/changes for these signatures in 
-24.5.1.2 [reverse.iter.ops].
+24.5.1.3 [reverse.iter.ops].
 
    
 
 
    [
@@ -13021,7 +13532,7 @@ this solution is safe and correct.
 
 
    
 
    281. std::min() and max() requirements overly restrictive
    
-
    Section: 25.5.7 [alg.min.max] Status: CD1
+
    Section: 25.4.7 [alg.min.max] Status: CD1
  Submitter: Martin Sebor Opened: 2000-12-02  Last modified: 2008-09-26
    
 
    View all other issues in [alg.min.max].
    
 
    View all issues with CD1 status.
    
@@ -13029,7 +13540,7 @@ this solution is safe and correct.
 
    Discussion:
    
 
    The requirements in 25.3.7, p1 and 4 call for T to satisfy the
 requirements of LessThanComparable ( [lessthancomparable])
-and CopyConstructible (X [utility.arg.requirements]).
+and CopyConstructible (20.2.1 [utility.arg.requirements]).
 Since the functions take and return their arguments and result by
 const reference, I believe the CopyConstructible requirement
 is unnecessary.
@@ -13111,7 +13622,7 @@ Howard, Bill, Pete, Benjamin, Nathan, Dietmar, Boris, and Martin.]
    
 
 
    
 
    283. std::replace() requirement incorrect/insufficient
    
-
    Section: 25.4.5 [alg.replace] Status: CD1
+
    Section: 25.3.5 [alg.replace] Status: CD1
  Submitter: Martin Sebor Opened: 2000-12-15  Last modified: 2008-09-26
    
 
    View all other issues in [alg.replace].
    
 
    View all issues with CD1 status.
    
@@ -13273,11 +13784,11 @@ imposing a greater restriction that what the standard currently says
 
 
    
 
    284. unportable example in 20.3.7, p6
    
-
    Section: 20.7.8 [comparisons] Status: CD1
+
    Section: 20.7.7 [comparisons] Status: CD1
  Submitter: Martin Sebor Opened: 2000-12-26  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
-
    The example in 20.7.8 [comparisons], p6 shows how to use the C
+
    The example in 20.7.7 [comparisons], p6 shows how to use the C
 library function strcmp() with the function pointer adapter
 ptr_fun(). But since it's unspecified whether the C library
 functions have extern "C" or extern
@@ -13289,7 +13800,7 @@ well-formed is unspecified.
 
 
 
    Proposed resolution:
    
-
    Change 20.7.8 [comparisons] paragraph 6 from:
    
+
    Change 20.7.7 [comparisons] paragraph 6 from:
    
 
    
   
    [Example:
    
   
        replace_if(v.begin(), v.end(), not1(bind2nd(ptr_fun(strcmp), "C")), "C++");
@@ -13357,7 +13868,7 @@ paragraphs mentioned above.
 
 
    
 
    286. <cstdlib> requirements missing size_t typedef
    
-
    Section: 25.6 [alg.c.library] Status: CD1
+
    Section: 25.5 [alg.c.library] Status: CD1
  Submitter: Judy Ward Opened: 2000-12-30  Last modified: 2008-09-26
    
 
    View all other issues in [alg.c.library].
    
 
    View all issues with CD1 status.
    
@@ -13416,7 +13927,7 @@ and Table 95 (section C.2) "Standard Macros" to include EILSEQ.
 
 
    
 
    291. Underspecification of set algorithms
    
-
    Section: 25.5.5 [alg.set.operations] Status: CD1
+
    Section: 25.4.5 [alg.set.operations] Status: CD1
  Submitter: Matt Austern Opened: 2001-01-03  Last modified: 2008-09-26
    
 
    View all other issues in [alg.set.operations].
    
 
    View all issues with CD1 status.
    
@@ -13473,7 +13984,7 @@ same way.
 
 
    Proposed resolution:
    
 
-
    Add the following to the end of 25.5.5.2 [set.union] paragraph 5:
    
+
    Add the following to the end of 25.4.5.2 [set.union] paragraph 5:
    
 
    
 If [first1, last1) contains m elements that are equivalent to
 each other and [first2, last2) contains n elements that are
@@ -13483,7 +13994,7 @@ from [first1, last1), and the last max(n-m, 0) of them from
 [first2, last2), in that order.
 
    
 
-
    Add the following to the end of 25.5.5.3 [set.intersection] paragraph 5:
    
+
    Add the following to the end of 25.4.5.3 [set.intersection] paragraph 5:
    
 
    
 If [first1, last1) contains m elements that are equivalent to each
 other and [first2, last2) contains n elements that are
@@ -13491,7 +14002,7 @@ equivalent to them, the first min(m, n) of those
 elements from [first1, last1) are copied to the output range.
 
    
 
-
    Add a new paragraph, Notes, after 25.5.5.4 [set.difference]
+
    Add a new paragraph, Notes, after 25.4.5.4 [set.difference]
 paragraph 4:
    
 
    
 If [first1, last1) contains m elements that are equivalent to each
@@ -13500,7 +14011,7 @@ equivalent to them, the last max(m-n, 0) elements from
 [first1, last1) are copied to the output range.
 
    
 
-
    Add a new paragraph, Notes, after 25.5.5.5 [set.symmetric.difference]
+
    Add a new paragraph, Notes, after 25.4.5.5 [set.symmetric.difference]
 paragraph 4:
    
 
    
 If [first1, last1) contains m elements that are equivalent to
@@ -13669,7 +14180,7 @@ putting in <cstdlib>.  That's issue 297. const_mem_fun_t<>::argument_type should be const T*
-
    Section: 20.7.9 [logical.operations] Status: CD1
+
    Section: 20.7.8 [logical.operations] Status: CD1
  Submitter: Martin Sebor Opened: 2001-01-06  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -13804,6 +14315,7 @@ or operator delete(ptr, std::nothrow) respectively.
 
    300. list::merge() specification incomplete
    
 
    Section: 23.3.4.4 [list.ops] Status: CD1
  Submitter: John Pedretti Opened: 2001-01-23  Last modified: 2008-09-26
    
+
    View other active issues in [list.ops].
    
 
    View all other issues in [list.ops].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -13901,7 +14413,7 @@ a mistake.
 
 
    
 
    303. Bitset input operator underspecified
    
-
    Section: 20.3.6.3 [bitset.operators] Status: CD1
+
    Section: 20.3.7.3 [bitset.operators] Status: CD1
  Submitter: Matt Austern Opened: 2001-02-05  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -14221,7 +14733,7 @@ container's reference type.
    
 
 
    
 I propose 3.  This does not preclude option 2 if we choose to do it
-later (see issue 96); the issues are independent.  Option
+later (see issue 96); the issues are independent.  Option
 3 offers a small step towards support for proxied containers.  This
 small step fixes a current contradiction, is easy for vendors to
 implement, is already implemented in at least one popular lib, and
@@ -14657,6 +15169,7 @@ as <memory>.
    
 
    315. Bad "range" in list::unique complexity
    
 
    Section: 23.3.4.4 [list.ops] Status: CD1
  Submitter: Andy Sawyer Opened: 2001-05-01  Last modified: 2008-09-26
    
+
    View other active issues in [list.ops].
    
 
    View all other issues in [list.ops].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -14684,6 +15197,7 @@ Change the "range" from (last - first) to [first, last).
 
    316. Vague text in Table 69
    
 
    Section: 23.2.4 [associative.reqmts] Status: CD1
  Submitter: Martin Sebor Opened: 2001-05-04  Last modified: 2008-09-26
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -15031,7 +15545,7 @@ requires that iterator_traits<const int*>::value_type is int.
 
 
    
 
    324. Do output iterators have value types?
    
-
    Section: 24.2.3 [output.iterators] Status: CD1
+
    Section: 24.2.2 [output.iterators] Status: CD1
  Submitter: Dave Abrahams Opened: 2001-06-07  Last modified: 2008-09-26
    
 
    View all other issues in [output.iterators].
    
 
    View all issues with CD1 status.
    
@@ -15389,7 +15903,7 @@ reallocation guarantees was inadvertant.
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-With the change in 17.6.4.10 [res.on.exception.handling] to state
+With the change in 17.6.4.11 [res.on.exception.handling] to state
    "An implementation may strengthen the exception-specification for a 
     non-virtual function by removing listed exceptions."
 (issue 119)
@@ -15692,7 +16206,7 @@ library (though a deprecated one).
    
 
  • 17.6.1.2 [headers] Headers/4
    • 
 
  • 17.6.3.6 [replacement.functions] Replacement functions/1
    • 
 
  • 17.6.4.4 [global.functions] Global or non-member functions/2
    • 
-
  • 17.6.4.8 [protection.within.classes] Protection within classes/1
    • 
+
  • 17.6.4.9 [protection.within.classes] Protection within classes/1
    • 
 
 
 
@@ -15703,7 +16217,7 @@ library (though a deprecated one).
    
 
 
    
 
    337. replace_copy_if's template parameter should be InputIterator
    
-
    Section: 25.4.5 [alg.replace] Status: CD1
+
    Section: 25.3.5 [alg.replace] Status: CD1
  Submitter: Detlef Vollmann Opened: 2001-09-07  Last modified: 2008-09-26
    
 
    View all other issues in [alg.replace].
    
 
    View all issues with CD1 status.
    
@@ -15711,7 +16225,7 @@ library (though a deprecated one).
    
 
    From c++std-edit-876:
    
 
 
    
-In section 25.4.5 [alg.replace] before p4: The name of the first
+In section 25.3.5 [alg.replace] before p4: The name of the first
 parameter of template replace_copy_if should be "InputIterator"
 instead of "Iterator".  According to 17.5.2.1 [type.descriptions] p1 the
 parameter name conveys real normative meaning.
@@ -15820,7 +16334,7 @@ clause 27, making the reference in 22.2.1 somewhat dubious.
     
    
     Several types defined in clause 27 are bitmask types. Each bitmask type
     can be implemented as an enumerated type that overloads certain operators,
-    as an integer type, or as a bitset (20.3.6 [template.bitset]).
+    as an integer type, or as a bitset (20.3.7 [template.bitset]).
     
    
 
    to read
    
     
    
@@ -16044,9 +16558,8 @@ declares struct tm as an incomplete type. However, table 48 in 21.6
 
 
    
 
    346. Some iterator member functions should be const
    
-
    Section: 24.2 [iterator.concepts] Status: CD1
+
    Section: X [iterator.concepts] Status: CD1
  Submitter: Jeremy Siek Opened: 2001-10-20  Last modified: 2008-09-30
    
-
    View other active issues in [iterator.concepts].
    
 
    View all other issues in [iterator.concepts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -16063,7 +16576,7 @@ make this more explicit and also fix a couple problems.
    
 
 
 
    Proposed resolution:
    
-
    In 24.2 [iterator.concepts] Change the first section of p9 from
+
    In X [iterator.concepts] Change the first section of p9 from
 "In the following sections, a and b denote values of X..." to
 "In the following sections, a and b denote values of type const X...".
    
 
@@ -16231,6 +16744,7 @@ In 24.6.2 [ostream.iterator], replace const char* delim with
 
    352. missing fpos requirements
    
 
    Section: 21.2.2 [char.traits.typedefs] Status: CD1
  Submitter: Martin Sebor Opened: 2001-12-02  Last modified: 2008-09-26
    
+
    View all other issues in [char.traits.typedefs].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
@@ -16287,6 +16801,7 @@ be considered NAD.
    
 
    354. Associative container lower/upper bound requirements
    
 
    Section: 23.2.4 [associative.reqmts] Status: CD1
  Submitter: Hans Aberg Opened: 2001-12-17  Last modified: 2008-09-26
    
+
    View other active issues in [associative.reqmts].
    
 
    View all other issues in [associative.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -16353,6 +16868,7 @@ key greater than k, or a.end() if such an element is not found.
 
    355. Operational semantics for a.back()
    
 
    Section: 23.2.3 [sequence.reqmts] Status: CD1
  Submitter: Yaroslav Mironov Opened: 2002-01-23  Last modified: 2008-09-26
    
+
    View other active issues in [sequence.reqmts].
    
 
    View all other issues in [sequence.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -16640,13 +17156,13 @@ prevents locale from being implemented efficiently.
 
 
    
 
    362. bind1st/bind2nd type safety
    
-
    Section: D.8 [depr.lib.binders] Status: CD1
+
    Section: D.9 [depr.lib.binders] Status: CD1
  Submitter: Andrew Demkin Opened: 2002-04-26  Last modified: 2008-09-26
    
 
    View all other issues in [depr.lib.binders].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-The definition of bind1st() (D.8 [depr.lib.binders]) can result in
+The definition of bind1st() (D.9 [depr.lib.binders]) can result in
 the construction of an unsafe binding between incompatible pointer
 types. For example, given a function whose first parameter type is
 'pointer to T', it's possible without error to bind an argument of
@@ -16673,19 +17189,19 @@ map its argument to the expected argument type of the bound function
 
      typename Operation::first_argument_type(x)
 
    
 
-
    A functional-style conversion (D.8 [depr.lib.binders]) is defined to
+
    A functional-style conversion (D.9 [depr.lib.binders]) is defined to
 be
-semantically equivalent to an explicit cast expression (D.8
+semantically equivalent to an explicit cast expression (D.9
 [depr.lib.binders]), which may (according to 5.4, paragraph 5) be
 interpreted
 as a reinterpret_cast, thus masking the error.
 
    
 
-
    The problem and proposed change also apply to D.8 [depr.lib.binders].
    
+
    The problem and proposed change also apply to D.9 [depr.lib.binders].
    
 
 
 
    Proposed resolution:
    
-
    Add this sentence to the end of D.8 [depr.lib.binders]/1:
+
    Add this sentence to the end of D.9 [depr.lib.binders]/1:
   "Binders bind1st and bind2nd are deprecated in
   favor of std::tr1::bind."
    
 
@@ -17347,7 +17863,7 @@ values, or that choose to detect any other kind of error, may return
 
 
    
 
    383. Bidirectional iterator assertion typo
    
-
    Section: 24.2.5 [bidirectional.iterators] Status: CD1
+
    Section: 24.2.4 [bidirectional.iterators] Status: CD1
  Submitter: ysapir (submitted via comp.std.c++) Opened: 2002-10-17  Last modified: 2008-09-26
    
 
    View all other issues in [bidirectional.iterators].
    
 
    View all issues with CD1 status.
    
@@ -17416,13 +17932,13 @@ Change the guarantee to "postcondition: r is dereferenceable."
 
 
    
 
    384. equal_range has unimplementable runtime complexity
    
-
    Section: 25.5.3.3 [equal.range] Status: CD1
+
    Section: 25.4.3.3 [equal.range] Status: CD1
  Submitter: Hans Bos Opened: 2002-10-18  Last modified: 2008-09-26
    
 
    View all other issues in [equal.range].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-Section 25.5.3.3 [equal.range]
+Section 25.4.3.3 [equal.range]
 states that at most 2 * log(last - first) + 1
 comparisons are allowed for equal_range.
 
    
@@ -17461,13 +17977,13 @@ but 2log(distance) + 4 for the worst case).
 
 
 
    Proposed resolution:
    
-
    In 25.5.3.1 [lower.bound]/4, change log(last - first) + 1
+
    In 25.4.3.1 [lower.bound]/4, change log(last - first) + 1
 to log2(last - first) + O(1).
    
 
-
    In 25.5.3.2 [upper.bound]/4, change log(last - first) + 1
+
    In 25.4.3.2 [upper.bound]/4, change log(last - first) + 1
 to log2(last - first) + O(1).
    
 
-
    In 25.5.3.3 [equal.range]/4, change 2*log(last - first) + 1
+
    In 25.4.3.3 [equal.range]/4, change 2*log(last - first) + 1
 to 2*log2(last - first) + O(1).
    
 
 
    [Matt provided wording]
    
@@ -17488,11 +18004,11 @@ to 2*log2(last - first) + O(1).
    
 
 
    
 
    386. Reverse iterator's operator[] has impossible return type
    
-
    Section: 24.5.1.2.11 [reverse.iter.op-=] Status: CD1
+
    Section: 24.5.1.3.11 [reverse.iter.op-=] Status: CD1
  Submitter: Matt Austern Opened: 2002-10-23  Last modified: 2009-05-01
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
-
    In 24.5.1.2.11 [reverse.iter.op-=], reverse_iterator<>::operator[] 
+
    In 24.5.1.3.11 [reverse.iter.op-=], reverse_iterator<>::operator[] 
 is specified as having a return type of reverse_iterator::reference,
 which is the same as iterator_traits<Iterator>::reference.
 (Where Iterator is the underlying iterator type.)
    
@@ -17518,7 +18034,7 @@ which is the same as iterator_traits<Iterator>::reference.
 
 
    Proposed resolution:
    
 
-
    In  [reverse.iter.requirements] change:
    
+
    In 24.5.1.2 [reverse.iter.requirements] change:
    
 
 
    
 
    reference operator[](difference_type n) const;
@@ -17528,7 +18044,7 @@ which is the same as iterator_traits<Iterator>::reference.
 
    to:
    
 
 
    
-
    unspecified operator[](difference_type n) const; // see 24.2.6 [random.access.iterators]
+
    unspecified operator[](difference_type n) const; // see 24.2.5 [random.access.iterators]
 
    
 
    
 
@@ -17818,7 +18334,7 @@ function."
 
    
 
 
    
-In 25.4.12 [alg.random.shuffle], there is no specification as to
+In 25.3.12 [alg.random.shuffle], there is no specification as to
 how the two parameter version of the function generates its random
 value.  I believe that all current implementations in fact call rand()
 (in contradiction with the requirement avove); if an implementation does
@@ -17859,7 +18375,7 @@ implementation is permitted to use rand.]
 
 
    
 
    396. what are characters zero and one
    
-
    Section: 20.3.6.1 [bitset.cons] Status: CD1
+
    Section: 20.3.7.1 [bitset.cons] Status: CD1
  Submitter: Martin Sebor Opened: 2003-01-05  Last modified: 2008-09-26
    
 
    View all other issues in [bitset.cons].
    
 
    View all issues with CD1 status.
    
@@ -17918,7 +18434,7 @@ We request that Howard submit a separate issue regarding the three to_string ove
 
 
    Proposed resolution:
    
 
    Change the constructor's function declaration immediately before 
-20.3.6.1 [bitset.cons] p3 to:
    
+20.3.7.1 [bitset.cons] p3 to:
    
 
        template <class charT, class traits, class Allocator>
     explicit
     bitset(const basic_string<charT, traits, Allocator>& str,
@@ -17927,7 +18443,7 @@ We request that Howard submit a separate issue regarding the three to_string ove
              basic_string<charT, traits, Allocator>::npos,
            charT zero = charT('0'), charT one = charT('1'))
 
    
-
    Change the first two sentences of 20.3.6.1 [bitset.cons] p6 to: "An
+
    Change the first two sentences of 20.3.7.1 [bitset.cons] p6 to: "An
 element of the constructed string has value 0 if the corresponding
 character in str, beginning at position pos,
 is zero. Otherwise, the element has the value 1.
    
@@ -17940,15 +18456,15 @@ is zero. Otherwise, the element has the value 1.
    
 
    
 
 
    Change the declaration of the to_string member function
-  immediately before 20.3.6.2 [bitset.members] p33 to:
    
+  immediately before 20.3.7.2 [bitset.members] p33 to:
    
 
        template <class charT, class traits, class Allocator>
     basic_string<charT, traits, Allocator> 
     to_string(charT zero = charT('0'), charT one = charT('1')) const;
 
    
-
    Change the last sentence of 20.3.6.2 [bitset.members] p33 to: "Bit
+
    Change the last sentence of 20.3.7.2 [bitset.members] p33 to: "Bit
   value 0 becomes the character zero, bit value 1 becomes the
   character one.
    
-
    Change 20.3.6.3 [bitset.operators] p8 to:
    
+
    Change 20.3.7.3 [bitset.operators] p8 to:
    
 
    Returns:
     
 
      os << x.template to_string<charT,traits,allocator<charT> >(
       use_facet<ctype<charT> >(os.getloc()).widen('0'),
@@ -17993,13 +18509,13 @@ The proposed wording neglects the 3 newer to_string overloads.
 
 
    
 
    400. redundant type cast in lib.allocator.members
    
-
    Section: 20.8.4.1 [allocator.members] Status: CD1
+
    Section: 20.8.8.1 [allocator.members] Status: CD1
  Submitter: Markus Mauhart Opened: 2003-02-27  Last modified: 2008-09-26
    
 
    View all other issues in [allocator.members].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-20.8.4.1 [allocator.members] allocator members, contains
+20.8.8.1 [allocator.members] allocator members, contains
 the following 3 lines:
 
    
 
@@ -18027,9 +18543,8 @@ Replace "((T*) p)" with "p".
 
 
    
 
    401.  incorrect type casts in table 32 in lib.allocator.requirements
    
-
    Section: X [allocator.requirements] Status: CD1
+
    Section: 20.2.2 [allocator.requirements] Status: CD1
  Submitter: Markus Mauhart Opened: 2003-02-27  Last modified: 2008-09-26
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -18111,21 +18626,20 @@ issue to Ready status to be voted into the WP at Kona.
 
 
    
 
    402. wrong new expression in [some_]allocator::construct
    
-
    Section: X [allocator.requirements], 20.8.4.1 [allocator.members] Status: CD1
+
    Section: 20.2.2 [allocator.requirements], 20.8.8.1 [allocator.members] Status: CD1
  Submitter: Markus Mauhart Opened: 2003-02-27  Last modified: 2008-09-26
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
 This applies to the new expression that is contained in both par12 of
-20.8.4.1 [allocator.members] and in par2 (table 32) of  [default.con.req].
+20.8.8.1 [allocator.members] and in par2 (table 32) of  [default.con.req].
 I think this new expression is wrong, involving unintended side
 effects.
 
    
 
 
-
    20.8.4.1 [allocator.members]  contains the following 3 lines:
    
+
    20.8.8.1 [allocator.members]  contains the following 3 lines:
    
 
 
      11 Returns: the largest value N for which the call allocate(N,0) might succeed.
      void construct(pointer p, const_reference val);
@@ -18303,13 +18817,13 @@ believed to be of limited value.
 
 
    
 
    405. qsort and POD
    
-
    Section: 25.6 [alg.c.library] Status: CD1
+
    Section: 25.5 [alg.c.library] Status: CD1
  Submitter: Ray Lischner Opened: 2003-04-08  Last modified: 2008-09-26
    
 
    View all other issues in [alg.c.library].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-Section 25.6 [alg.c.library] describes bsearch and qsort, from the C
+Section 25.5 [alg.c.library] describes bsearch and qsort, from the C
 standard library. Paragraph 4 does not list any restrictions on qsort,
 but it should limit the base parameter to point to POD.  Presumably,
 qsort sorts the array by copying bytes, which requires POD.
@@ -18318,7 +18832,7 @@ qsort sorts the array by copying bytes, which requires POD.
 
 
    Proposed resolution:
    
 
    
-In 25.6 [alg.c.library] paragraph 4, just after the declarations and
+In 25.5 [alg.c.library] paragraph 4, just after the declarations and
 before the nonnormative note, add these words: "both of which have the
 same behavior as the original declaration.  The behavior is undefined
 unless the objects in the array pointed to by base are of POD
@@ -18371,14 +18885,13 @@ existing implementation.
 
 
    
 
    407. Can singular iterators be destroyed?
    
-
    Section: 24.2 [iterator.concepts] Status: CD1
+
    Section: X [iterator.concepts] Status: CD1
  Submitter: Nathan Myers Opened: 2003-06-03  Last modified: 2008-09-30
    
-
    View other active issues in [iterator.concepts].
    
 
    View all other issues in [iterator.concepts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-Clause 24.2 [iterator.concepts], paragraph 5, says that the only expression
+Clause X [iterator.concepts], paragraph 5, says that the only expression
 that is defined for a singular iterator is "an assignment of a
 non-singular value to an iterator that holds a singular value".  This 
 means that destroying a singular iterator (e.g. letting an automatic
@@ -18574,13 +19087,13 @@ supposed to do, but we ought to spell it out.
    
 
 
    
 
    411. Wrong names of set member functions
    
-
    Section: 25.5.5 [alg.set.operations] Status: CD1
+
    Section: 25.4.5 [alg.set.operations] Status: CD1
  Submitter: Daniel Frey Opened: 2003-07-09  Last modified: 2008-09-26
    
 
    View all other issues in [alg.set.operations].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-25.5.5 [alg.set.operations] paragraph 1 reads:
+25.4.5 [alg.set.operations] paragraph 1 reads:
 "The semantics of the set operations are generalized to multisets in a 
 standard way by defining union() to contain the maximum number of 
 occurrences of every element, intersection() to contain the minimum, and 
@@ -18878,6 +19391,124 @@ to match the type to which they refer.--end note]
 
 
 
+
    
+
    419. istream extractors not setting failbit if eofbit is already set
    
+
    Section: 27.7.1.1.3 [istream::sentry] Status: WP
+ Submitter: Martin Sebor Opened: 2003-09-18  Last modified: 2009-10-26
    
+
    View all other issues in [istream::sentry].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+        
    
+
+27.7.1.1.3 [istream::sentry], p2 says that istream::sentry ctor prepares for input if is.good()
+is true. p4 then goes on to say that the ctor sets the sentry::ok_ member to
+true if the stream state is good after any preparation. 27.7.1.2.1 [istream.formatted.reqmts], p1 then
+says that a formatted input function endeavors to obtain the requested input
+if the sentry's operator bool() returns true.
+
+Given these requirements, no formatted extractor should ever set failbit if
+the initial stream rdstate() == eofbit. That is contrary to the behavior of
+all implementations I tested. The program below prints out
+
+eof = 1, fail = 0
+eof = 1, fail = 1
+
+on all of them.
+        
    
+
    +#include <sstream>
+#include <cstdio>
+
+int main()
+{
+    std::istringstream strm ("1");
+
+    int i = 0;
+
+    strm >> i;
+
+    std::printf ("eof = %d, fail = %d\n",
+                 !!strm.eof (), !!strm.fail ());
+
+    strm >> i;
+
+    std::printf ("eof = %d, fail = %d\n",
+                 !!strm.eof (), !!strm.fail ());
+}
+
+
    
+        
    
+
    
+
+Comments from Jerry Schwarz (c++std-lib-11373):
+
    
+
+Jerry Schwarz wrote:
+
    
+
+I don't know where (if anywhere) it says it in the standard, but the
+formatted extractors are supposed to set failbit if they don't extract
+any characters. If they didn't then simple loops like
+
    
+
+while (cin >> x);
+
    
+
+would loop forever.
+
    
+
+Further comments from Martin Sebor:
+
    
+
+The question is which part of the extraction should prevent this from happening
+by setting failbit when eofbit is already set. It could either be the sentry
+object or the extractor. It seems that most implementations have chosen to
+set failbit in the sentry [...] so that's the text that will need to be
+corrected. 
+
+        
    
+
    
+Pre Berlin:  This issue is related to 342.  If the sentry
+sets failbit when it finds eofbit already set, then
+you can never seek away from the end of stream.
+
    
+
    Kona: Possibly NAD.  If eofbit is set then good() will return false.  We
+  then set ok to false.  We believe that the sentry's
+  constructor should always set failbit when ok is false, and
+  we also think the standard already says that.  Possibly it could be
+  clearer.
     
+
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+Moved to Ready.
+
    
+
+    
+
+
    Proposed resolution:
    
+
    
+Change 27.7.1.1.3 [istream::sentry], p2 to:
+
    
+
+
    
+
    explicit sentry(basic_istream<charT,traits>& is , bool noskipws = false);
    
+
    
+-2- Effects: If is.good() is true
+false, calls is.setstate(failbit). 
+Otherwise prepares for formatted or unformatted input. ...
+
    
+
    
+
+
+
+
+
+
 
    
 
    420. is std::FILE a complete type?
    
 
    Section: 27.9.1 [fstreams] Status: CD1
@@ -18982,7 +19613,7 @@ use the right wording.]
    
 
 
    
 
    425. return value of std::get_temporary_buffer
    
-
    Section: 20.8.7 [temporary.buffer] Status: CD1
+
    Section: 20.8.11 [temporary.buffer] Status: CD1
  Submitter: Martin Sebor Opened: 2003-09-18  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -19008,7 +19639,7 @@ no storage can be obtained or if n <= 0."
    
 
 
    
 
    426. search_n(), fill_n(), and generate_n() with negative n
    
-
    Section: 25.3.12 [alg.search], 25.4.6 [alg.fill], 25.4.7 [alg.generate] Status: CD1
+
    Section: 25.2.12 [alg.search], 25.3.6 [alg.fill], 25.3.7 [alg.generate] Status: CD1
  Submitter: Martin Sebor Opened: 2003-09-18  Last modified: 2008-09-26
    
 
    View all other issues in [alg.search].
    
 
    View all issues with CD1 status.
    
@@ -19412,7 +20043,7 @@ initialized range.
    
 
 
    
 
    434. bitset::to_string() hard to use
    
-
    Section: 20.3.6.2 [bitset.members] Status: CD1
+
    Section: 20.3.7.2 [bitset.members] Status: CD1
  Submitter: Martin Sebor Opened: 2003-10-15  Last modified: 2009-05-01
    
 
    View all other issues in [bitset.members].
    
 
    View all issues with CD1 status.
    
@@ -19567,6 +20198,7 @@ text.]
    
 
    438. Ambiguity in the "do the right thing" clause
    
 
    Section: 23.2.3 [sequence.reqmts] Status: CD1
  Submitter: Howard Hinnant Opened: 2003-10-20  Last modified: 2009-05-01
    
+
    View other active issues in [sequence.reqmts].
    
 
    View all other issues in [sequence.reqmts].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -20035,7 +20667,7 @@ LWG issue
 
 
    
 
    445. iterator_traits::reference unspecified for some iterator categories
    
-
    Section: D.10.1 [iterator.traits] Status: CD1
+
    Section: 24.4.1 [iterator.traits] Status: CD1
  Submitter: Dave Abrahams Opened: 2003-12-09  Last modified: 2009-05-01
    
 
    View all other issues in [iterator.traits].
    
 
    View all issues with CD1 status.
    
@@ -20133,7 +20765,7 @@ so I've changed the wording to say that those types may be
 
 
    Proposed resolution:
    
 
-
    In D.10.1 [iterator.traits], after:
    
+
    In 24.4.1 [iterator.traits], after:
    
 
 
    
 be defined as the iterator's difference type, value type and iterator
@@ -20152,7 +20784,7 @@ is, the same type as the type of *a and a->,
 respectively.
    
 
    
 
-
    In D.10.1 [iterator.traits], change:
    
+
    In 24.4.1 [iterator.traits], change:
    
 
 
    
 In the case of an output iterator, the types
    
@@ -20201,9 +20833,8 @@ needed to be changed.
 
 
    
 
    448. Random Access Iterators over abstract classes
    
-
    Section: 24.2.6 [random.access.iterators] Status: CD1
+
    Section: 24.2.5 [random.access.iterators] Status: CD1
  Submitter: Dave Abrahams Opened: 2004-01-07  Last modified: 2008-09-26
    
-
    View other active issues in [random.access.iterators].
    
 
    View all other issues in [random.access.iterators].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -20461,7 +21092,7 @@ using-declarations (7.3.3 [namespace.udecl]).
 
    
 
 
    
-Change D.5 [depr.c.headers], para. 2-3:
+Change D.6 [depr.c.headers], para. 2-3:
 
    
 
 
    
@@ -20493,7 +21124,7 @@ names within the namespace std. -- end example]
 
 
    
 
    457. bitset constructor: incorrect number of initialized bits
    
-
    Section: 20.3.6.1 [bitset.cons] Status: CD1
+
    Section: 20.3.7.1 [bitset.cons] Status: CD1
  Submitter: Dag Henriksson Opened: 2004-01-30  Last modified: 2009-05-01
    
 
    View all other issues in [bitset.cons].
    
 
    View all issues with CD1 status.
    
@@ -20513,7 +21144,7 @@ guaranteed to have any corresponding bit values in val.
 
 
 
    Proposed resolution:
    
-
    In 20.3.6.1 [bitset.cons] paragraph 2, change "M is the smaller of
+
    In 20.3.7.1 [bitset.cons] paragraph 2, change "M is the smaller of
   N and the value CHAR_BIT * sizeof (unsigned long). (249)" to
   "M is the smaller of N and the number of bits in
   the value representation (section 3.9 [basic.types]) of unsigned
@@ -20671,7 +21302,6 @@ An implementation may also accept additional implementation-defined formats.
 
    464. Suggestion for new member functions in standard containers
    
 
    Section: 23.3.6 [vector], 23.4.1 [map] Status: CD1
  Submitter: Thorsten Ottosen Opened: 2004-05-12  Last modified: 2008-09-26
    
-
    View other active issues in [vector].
    
 
    View all other issues in [vector].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -20923,7 +21553,6 @@ the value need not be valid.
 
    469. vector<bool> ill-formed relational operators
    
 
    Section: 23.3.6 [vector] Status: CD1
  Submitter: Martin Sebor Opened: 2004-06-28  Last modified: 2009-05-01
    
-
    View other active issues in [vector].
    
 
    View all other issues in [vector].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -20973,7 +21602,7 @@ I propose to strike the Footnote.
 
 
    
 
    475. May the function object passed to for_each modify the elements of the iterated sequence?
    
-
    Section: 25.3.4 [alg.foreach] Status: CD1
+
    Section: 25.2.4 [alg.foreach] Status: CD1
  Submitter: Stephan T. Lavavej, Jaakko Jarvi Opened: 2004-07-09  Last modified: 2008-09-26
    
 
    View all other issues in [alg.foreach].
    
 
    View all issues with CD1 status.
    
@@ -21038,7 +21667,7 @@ passed to for_each modify its argument.
    
 
 
 
    Proposed resolution:
    
-
    Add a nonnormative note to the Effects in 25.3.4 [alg.foreach]: If
+
    Add a nonnormative note to the Effects in 25.2.4 [alg.foreach]: If
 the type of 'first' satisfies the requirements of a mutable iterator,
 'f' may apply nonconstant functions through the dereferenced iterators
 passed to it.
@@ -21058,7 +21687,7 @@ passed to it.
 
 
    
 
    478. Should forward iterator requirements table have a line for r->m?
    
-
    Section: 24.2.4 [forward.iterators] Status: CD1
+
    Section: 24.2.3 [forward.iterators] Status: CD1
  Submitter: Dave Abrahams Opened: 2004-07-11  Last modified: 2008-09-26
    
 
    View all other issues in [forward.iterators].
    
 
    View all issues with CD1 status.
    
@@ -21127,7 +21756,7 @@ This is a defect because it constrains an lvalue to returning a modifiable lvalu
 
 
    
 
    488. rotate throws away useful information
    
-
    Section: 25.4.11 [alg.rotate] Status: CD1
+
    Section: 25.3.11 [alg.rotate] Status: CD1
  Submitter: Howard Hinnant Opened: 2004-11-22  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -21176,14 +21805,14 @@ a significant benefit to the change.
                 ForwardIterator last);
 
    
 
-
    In 25.4.11 [alg.rotate], change:
    
+
    In 25.3.11 [alg.rotate], change:
    
 
 
      template<class ForwardIterator>
     void ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
                 ForwardIterator last);
 
    
 
-
    In 25.4.11 [alg.rotate] insert a new paragraph after p1:
    
+
    In 25.3.11 [alg.rotate] insert a new paragraph after p1:
    
 
 
    
 
    Returns: first + (last - middle).
    
@@ -21291,7 +21920,6 @@ requirements of charT (described in 21 [strings]).
 
    496. Illegal use of "T" in vector<bool>
    
 
    Section: 23.3.6 [vector] Status: CD1
  Submitter: richard@ex-parrot.com Opened: 2005-02-10  Last modified: 2008-09-26
    
-
    View other active issues in [vector].
    
 
    View all other issues in [vector].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -21375,6 +22003,152 @@ at runtime.
 
 
 
+
    
+
    498. Requirements for partition() and stable_partition() too strong
    
+
    Section: 25.3.13 [alg.partitions] Status: WP
+ Submitter: Sean Parent, Joe Gottman Opened: 2005-05-04  Last modified: 2009-10-26
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+Problem:
+The iterator requirements for partition() and stable_partition() [25.2.12]
+are listed as BidirectionalIterator, however, there are efficient algorithms
+for these functions that only require ForwardIterator that have been known
+since before the standard existed. The SGI implementation includes these (see
+http://www.sgi.com/tech/stl/partition.html
+and
+http://www.sgi.com/tech/stl/stable_partition.html).
+
    
+
+
    [
+2009-04-30 Alisdair adds:
+]
    
+
+
+
    
+
    
+Now we have concepts this is easier to express!
+
    
+
    
+Proposed resolution:
+
    
+
    
+Add the following signature to:
+
    
+
    
+Header <algorithm> synopsis  [algorithms.syn]
    
+p3 Partitions 25.3.13 [alg.partitions]
+
    
+
     template<ForwardIterator Iter, Predicate<auto, Iter::value_type> Pred>
+   requires ShuffleIterator<Iter>
+         && CopyConstructible<Pred>
+   Iter partition(Iter first, Iter last, Pred pred);
+
    
+
+
    
+Update p3 Partitions 25.3.13 [alg.partitions]:
+
    
+
+
    
+
    
+Complexity: At most (last - first)/2 swaps. Exactly last - first
+applications of the predicate
+are done.
+
+If Iter satisfies BidirectionalIterator, at most (last -
+first)/2 swaps. Exactly last - first applications of the predicate
+are done.
+
+
    
+
    
+If Iter merely satisfied ForwardIterator at most (last - first) swaps
+are done. Exactly (last - first) applications of the predicate are done.
+
    
+
    
+
+
    
+[Editorial note: I looked for existing precedent in how we might call out
+distinct overloads overloads from a set of constrained templates, but there
+is not much existing practice to lean on.   advance/distance were the only
+algorithms I could find, and that wording is no clearer.]
+
    
+
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Hinnant: if you want to partition your std::forward_list, you'll need
+partition() to accept ForwardIterators.
+
    
+
    
+No objection to Ready.
+
    
+
    
+Move to Ready.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change 25.2.12 from 
    
+
    template<class BidirectionalIterator, class Predicate> 
+BidirectionalIterator partition(BidirectionalIterato r first, 
+                                BidirectionalIterator last, 
+                                Predicate pred); 
+
    
+
    to 
    
+
    template<class ForwardIterator, class Predicate> 
+ForwardIterator partition(ForwardIterator first, 
+                          ForwardIterator last, 
+                          Predicate pred); 
+
    
+
    Change the complexity from 
    
+
+
    
+At most (last - first)/2 swaps are done. Exactly (last - first) 
+applications of the predicate are done. 
+
    
+
+
    to 
    
+
+
    
+If ForwardIterator is a bidirectional_iterator, at most (last - first)/2 
+swaps are done; otherwise at most (last - first) swaps are done. Exactly 
+(last - first) applications of the predicate are done. 
+
    
+
+
+
+
    Rationale:
    
+
    
+Partition is a "foundation" algorithm useful in many contexts (like sorting
+as just one example) - my motivation for extending it to include forward
+iterators is foward_list - without this extension you can't partition an foward_list
+(without writing your own partition). Holes like this in the standard
+library weaken the argument for generic programming (ideally I'd be able
+to provide a library that would refine std::partition() to other concepts
+without fear of conflicting with other libraries doing the same - but
+that is a digression). I consider the fact that partition isn't defined
+to work for ForwardIterator a minor embarrassment.
+
    
+
+
    [Mont Tremblant: Moved to Open, request motivation and use cases
+by next meeting. Sean provided further rationale by post-meeting
+mailing.]
    
+
+
+
+
+
+
+
 
    
 
    505. Result_type in random distribution requirements
    
 
    Section: X [rand.req], TR1 5.1.1 [tr.rand.req] Status: CD1
@@ -21615,7 +22389,6 @@ preserves the relative ordering of equivalent elements.
    
 
    519. Data() undocumented
    
 
    Section: 23.3.1 [array], TR1 6.2.2 [tr.array.array] Status: CD1
  Submitter: Pete Becker Opened: 2005-07-03  Last modified: 2008-09-26
    
-
    View other active issues in [array].
    
 
    View all other issues in [array].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -21648,7 +22421,7 @@ of data() is unspecified.
 
 
    
 
    520. Result_of and pointers to data members
    
-
    Section: 20.7.12.1 [func.bind], TR1 3.6 [tr.func.bind] Status: CD1
+
    Section: 20.7.11.1 [func.bind], TR1 3.6 [tr.func.bind] Status: CD1
  Submitter: Pete Becker Opened: 2005-07-03  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -21942,7 +22715,7 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
 
 
    
 
    527. tr1::bind has lost its Throws clause
    
-
    Section: 20.7.12.1.3 [func.bind.bind], TR1 3.6.3 [tr.func.bind.bind] Status: CD1
+
    Section: 20.7.11.1.3 [func.bind.bind], TR1 3.6.3 [tr.func.bind.bind] Status: CD1
  Submitter: Peter Dimov Opened: 2005-10-01  Last modified: 2008-09-26
    
 
    View other active issues in [func.bind.bind].
    
 
    View all other issues in [func.bind.bind].
    
@@ -22010,7 +22783,7 @@ throws an exception.
 
 
    Proposed resolution:
    
 
    
-In 20.7.12.1.3 [func.bind.bind], add a new paragraph after p2:
+In 20.7.11.1.3 [func.bind.bind], add a new paragraph after p2:
 
    
 
 
    
@@ -22019,7 +22792,7 @@ in the BoundArgs... pack expansion throws an exception.
 
    
 
 
    
-In 20.7.12.1.3 [func.bind.bind], add a new paragraph after p4:
+In 20.7.11.1.3 [func.bind.bind], add a new paragraph after p4:
 
    
 
 
    
@@ -22163,7 +22936,7 @@ writing to out of bounds memory when n == 0.  Martin provided fix.
 
 
    
 
    533. typo in 2.2.3.10/1
    
-
    Section: 20.8.10.2.11 [util.smartptr.getdeleter], TR1 2.2.3.10 [tr.util.smartptr.getdeleter] Status: CD1
+
    Section: 20.8.15.2.11 [util.smartptr.getdeleter], TR1 2.2.3.10 [tr.util.smartptr.getdeleter] Status: CD1
  Submitter: Paolo Carlini Opened: 2005-11-09  Last modified: 2009-05-01
    
 
    View all other issues in [util.smartptr.getdeleter].
    
 
    View all issues with CD1 status.
    
@@ -22429,7 +23202,7 @@ After 27.6.2.4p3 change:
 
 
    
 
    538. 241 again: Does unique_copy() require CopyConstructible and Assignable?
    
-
    Section: 25.4.9 [alg.unique] Status: CD1
+
    Section: 25.3.9 [alg.unique] Status: CD1
  Submitter: Howard Hinnant Opened: 2006-02-09  Last modified: 2008-09-26
    
 
    View all other issues in [alg.unique].
    
 
    View all issues with CD1 status.
    
@@ -22487,7 +23260,7 @@ Otherwise CopyConstructible is not required.
 
 
    
 
    540. shared_ptr<void>::operator*()
    
-
    Section: 20.8.10.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] Status: CD1
+
    Section: 20.8.15.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] Status: CD1
  Submitter: Martin Sebor Opened: 2005-10-15  Last modified: 2008-09-26
    
 
    View all other issues in [util.smartptr.shared.obs].
    
 
    View all issues with CD1 status.
    
@@ -22545,9 +23318,8 @@ definition) of the function shall be well-formed.
 
 
    
 
    541. shared_ptr template assignment and void
    
-
    Section: 20.8.10.2 [util.smartptr.shared], TR1 2.2.3 [tr.util.smartptr.shared] Status: CD1
+
    Section: 20.8.15.2 [util.smartptr.shared], TR1 2.2.3 [tr.util.smartptr.shared] Status: CD1
  Submitter: Martin Sebor Opened: 2005-10-16  Last modified: 2008-09-26
    
-
    View other active issues in [util.smartptr.shared].
    
 
    View all other issues in [util.smartptr.shared].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -22626,7 +23398,7 @@ public:
 
 
    
 
    542. shared_ptr observers
    
-
    Section: 20.8.10.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] Status: CD1
+
    Section: 20.8.15.2.5 [util.smartptr.shared.obs], TR1 2.2.3.5 [tr.util.smartptr.shared.obs] Status: CD1
  Submitter: Martin Sebor Opened: 2005-10-18  Last modified: 2008-09-26
    
 
    View all other issues in [util.smartptr.shared.obs].
    
 
    View all issues with CD1 status.
    
@@ -22666,7 +23438,7 @@ capture the intent.
 
 
    Proposed resolution:
    
 
    
-Change 20.8.10.2.5 [util.smartptr.shared.obs] p12:
+Change 20.8.15.2.5 [util.smartptr.shared.obs] p12:
 
    
 
    
 [Note: use_count() is not necessarily efficient. Use only for
@@ -22674,7 +23446,7 @@ debugging and testing purposes, not for production code. --end note
 
    
 
 
    
-Change 20.8.10.3.5 [util.smartptr.weak.obs] p3:
+Change 20.8.15.3.5 [util.smartptr.weak.obs] p3:
 
    
 
    
 [Note: use_count() is not necessarily efficient. Use only for
@@ -22763,7 +23535,7 @@ lengths, and strides, as explained in the previous section.
 
 
    
 
    545. When is a deleter deleted?
    
-
    Section: 20.8.10.2.11 [util.smartptr.getdeleter], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] Status: CD1
+
    Section: 20.8.15.2.11 [util.smartptr.getdeleter], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] Status: CD1
  Submitter: Matt Austern Opened: 2006-01-10  Last modified: 2008-09-26
    
 
    View all other issues in [util.smartptr.getdeleter].
    
 
    View all issues with CD1 status.
    
@@ -22781,7 +23553,7 @@ instances). We should say which it is.
 
 
    Proposed resolution:
    
 
    
-Add after the first sentence of 20.8.10.2.11 [util.smartptr.getdeleter]/1:
+Add after the first sentence of 20.8.15.2.11 [util.smartptr.getdeleter]/1:
 
    
 
    
 
    
@@ -23000,7 +23772,7 @@ note]
 
 
    
 
    552. random_shuffle and its generator
    
-
    Section: 25.4.12 [alg.random.shuffle] Status: CD1
+
    Section: 25.3.12 [alg.random.shuffle] Status: CD1
  Submitter: Martin Sebor Opened: 2006-01-25  Last modified: 2008-09-26
    
 
    View all other issues in [alg.random.shuffle].
    
 
    View all issues with CD1 status.
    
@@ -23117,7 +23889,7 @@ automatically.
 
 
    
 
    561. inserter overly generic
    
-
    Section: 24.7.6.5 [inserter] Status: CD1
+
    Section: 24.5.2.6.5 [inserter] Status: CD1
  Submitter: Howard Hinnant Opened: 2006-02-21  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -23434,6 +24206,160 @@ Kona (2007) Moved to Ready.
 
 
 
+
    
+
    564. stringbuf seekpos underspecified
    
+
    Section: 27.8.1.4 [stringbuf.virtuals] Status: WP
+ Submitter: Martin Sebor Opened: 2006-02-23  Last modified: 2009-10-26
    
+
    View all other issues in [stringbuf.virtuals].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+The   effects  of  the   seekpos()  member   function  of
+basic_stringbuf  simply say  that the  function positions
+the  input and/or  output  sequences  but fail  to  spell out  exactly
+how. This is in contrast  to the detail in which seekoff()
+is described.
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+        
    
+
+Change 27.7.1.3, p13 to read:
+
+        
    
+
    
+
    
+-13- Effects: Equivalent to seekoff(off_type(sp), ios_base::beg,
+which). Alters the stream position within the controlled sequences,
+if possible, to correspond to the stream position stored in sp
+(as described below).
+
    
+
      
+
    • If (which & ios_base::in) != 0, positions the input sequence.
      • 
+
    • If (which & ios_base::out) != 0, positions the output sequence.
      • 
+
    • If sp is an invalid stream position, or if the function
+positions neither sequence, the positioning operation fails. If sp
+has not been obtained by a previous successful call to one of the positioning
+functions (seekoff, seekpos, tellg, tellp)
+the effect is undefined.
      • 
+
    
+
    
+
+
+
    [
+Kona (2007): A pos_type is a position in a stream by
+definition, so there is no ambiguity as to what it means. Proposed
+Disposition: NAD
+]
    
+
+
+
    [
+Post-Kona Martin adds:
+I'm afraid I disagree
+with the Kona '07 rationale for marking it NAD. The only text
+that describes precisely what it means to position the input
+or output sequence is in seekoff(). The seekpos() Effects
+clause is inadequate in comparison and the proposed resolution
+plugs the hole by specifying seekpos() in terms of seekoff().
+]
    
+
+
+
+
+
+
    
+
    565. xsputn inefficient
    
+
    Section: 27.6.2.4.5 [streambuf.virt.put] Status: WP
+ Submitter: Martin Sebor Opened: 2006-02-23  Last modified: 2009-10-26
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+        
    
+
+streambuf::xsputn()  is  specified  to  have  the  effect  of
+"writing up to  n characters to the output  sequence as if by
+repeated calls to sputc(c)."
+
+        
    
+        
    
+
+Since  sputc() is required  to call  overflow() when
+(pptr()    ==   epptr())    is   true,    strictly   speaking
+xsputn()  should do  the same.   However, doing  so  would be
+suboptimal in  some interesting cases,  such as in unbuffered  mode or
+when the buffer is basic_stringbuf.
+
+        
    
+        
    
+
+Assuming  calling overflow()  is  not really  intended to  be
+required  and the  wording is  simply  meant to  describe the  general
+effect of appending to the end  of the sequence it would be worthwhile
+to  mention in  xsputn() that  the function  is  not actually
+required to cause a call to overflow().
+
+        
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+        
    
+
+Add the following sentence  to the xsputn() Effects clause in
+27.5.2.4.5, p1 (N1804):
+
+        
    
+        
        
+            
    
+-1- Effects: Writes up to n characters to the output
+sequence as if by repeated calls to sputc(c). The characters 
+written are obtained from successive elements of the array whose first element
+is designated by s. Writing stops when either n
+characters have been written or a call to sputc(c) would return
+traits::eof(). It is  uspecified whether the function  calls
+overflow() when (pptr() ==  epptr()) becomes true or whether
+it achieves the same effects by other means.
+            
    
+        
        
+        
    
+
+In addition,  I suggest to  add a footnote  to this function  with the
+same text as Footnote 292 to  make it extra clear that derived classes
+are permitted to override xsputn() for efficiency.
+
+        
    
+
+
+
    [
+Kona (2007): We want to permit a streambuf that streams output directly
+to a device without making calls to sputc or overflow. We believe that
+has always been the intention of the committee. We believe that the
+proposed wording doesn't accomplish that. Proposed Disposition: Open
+]
    
+
+
+
+
+
 
    
 
    566. array forms of unformatted input function undefined for zero-element arrays
    
 
    Section: 27.7.1.3 [istream.unformatted] Status: CD1
@@ -23627,7 +24553,7 @@ Disposition: Review
 
 
    
 
    575. the specification of ~shared_ptr is MT-unfriendly, makes implementation assumptions
    
-
    Section: 20.8.10.2.2 [util.smartptr.shared.dest], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] Status: CD1
+
    Section: 20.8.15.2.2 [util.smartptr.shared.dest], TR1 2.2.3.2 [tr.util.smartptr.shared.dest] Status: CD1
  Submitter: Peter Dimov Opened: 2006-04-23  Last modified: 2008-09-26
    
 
    View all other issues in [util.smartptr.shared.dest].
    
 
    View all issues with CD1 status.
    
@@ -23706,7 +24632,7 @@ after *this is destroyed. --end note]
 
 
    
 
    576. find_first_of is overconstrained
    
-
    Section: 25.3.7 [alg.find.first.of] Status: CD1
+
    Section: 25.2.7 [alg.find.first.of] Status: CD1
  Submitter: Doug Gregor Opened: 2006-04-25  Last modified: 2008-09-26
    
 
    View all other issues in [alg.find.first.of].
    
 
    View all issues with CD1 status.
    
@@ -23759,7 +24685,7 @@ template<class ForwardIterator1InputIterator1, class Fo
 
 
    
 
    577. upper_bound(first, last, ...) cannot return last
    
-
    Section: 25.5.3.2 [upper.bound] Status: CD1
+
    Section: 25.4.3.2 [upper.bound] Status: CD1
  Submitter: Seungbeom Kim Opened: 2006-05-03  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -23809,7 +24735,7 @@ conditions hold: !(value < *j) or comp(value, *j)
 
 
    
 
    578. purpose of hint to allocator::allocate()
    
-
    Section: 20.8.4.1 [allocator.members] Status: CD1
+
    Section: 20.8.8.1 [allocator.members] Status: CD1
  Submitter: Martin Sebor Opened: 2006-05-17  Last modified: 2008-09-26
    
 
    View all other issues in [allocator.members].
    
 
    View all issues with CD1 status.
    
@@ -25068,7 +25994,7 @@ and accept my apologies for the oversight.
 
 
    
 
    610. Suggested non-normative note for C++0x
    
-
    Section: 20.7.16.2.1 [func.wrap.func.con], TR1 3.7.2.1 [tr.func.wrap.func.con] Status: CD1
+
    Section: 20.7.15.2.1 [func.wrap.func.con], TR1 3.7.2.1 [tr.func.wrap.func.con] Status: CD1
  Submitter: Scott Meyers Opened: 2006-11-02  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -25705,7 +26631,7 @@ dtor? Should the  dtor catch and swallow it or  should it propagate it
 to the caller?  The text doesn't  seem to provide any guidance in this
 regard  other  than  the  general  restriction on  throwing  (but  not
 propagating)  exceptions  from   destructors  of  library  classes  in
-17.6.4.10 [res.on.exception.handling].
+17.6.4.11 [res.on.exception.handling].
 
         
    
         
    
@@ -25820,7 +26746,7 @@ And to make the following edits in 27.9.1.2 [filebuf.cons].
 close().    If  an   exception  occurs   during  the
 destruction of the object, including the call to close(),
 the     exception    is     caught    but     not     rethrown    (see
-17.6.4.10 [res.on.exception.handling]).
+17.6.4.11 [res.on.exception.handling]).
 
             
    
         
    
@@ -26123,9 +27049,185 @@ will extract unambiguously.]
 
 
 
+
    
+
    630. arrays of valarray
    
+
    Section: 26.6.2.1 [valarray.cons] Status: WP
+ Submitter: Martin Sebor Opened: 2007-01-28  Last modified: 2009-10-26
    
+
    View all other issues in [valarray.cons].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+        
    
+
+Section 26.2 [numeric.requirements], p1     suggests     that     a
+valarray  specialization on  a  type T  that
+satisfies  the requirements enumerated  in the  paragraph is  itself a
+valid  type   on  which  valarray   may  be  instantiated
+(Footnote       269        makes       this       clear).        I.e.,
+valarray<valarray<T>  > is  valid as  long as
+T   is   valid.    However,  since   implementations   of
+valarray are permitted to initialize storage allocated by
+the class by  invoking the default ctor of  T followed by
+the    copy    assignment    operator,   such    implementations    of
+valarray   wouldn't  work  with   (perhaps  user-defined)
+specializations of valarray whose assignment operator had
+undefined behavior when the size of its argument didn't match the size
+of *this.  By "wouldn't work" I mean that it would
+be  impossible  to resize  such  an array  of  arrays  by calling  the
+resize() member  function on it if the  function used the
+copy  assignment operator  after constructing  all elements  using the
+default  ctor (e.g.,  by invoking  new  value_type[N]) to
+obtain default-initialized storage) as it's permitted to do.
+
+        
    
+        
    
+
+Stated      more     generally,      the      problem     is      that
+valarray<valarray<T>  >::resize(size_t) isn't
+required or  guaranteed to have well-defined semantics  for every type
+T     that      satisfies     all     requirements     in
+26.2 [numeric.requirements].
+
+        
    
+        
    
+
+I  believe  this  problem  was  introduced  by  the  adoption  of  the
+resolution                outlined                in                N0857,
+Assignment  of  valarrays,  from  1996.   The  copy  assignment
+operator  of  the original  numerical  array  classes  proposed in  N0280,
+as      well       as      the      one       proposed      in      N0308
+(both  from 1993), had  well-defined semantics  for arrays  of unequal
+size (the  latter explicitly  only when *this  was empty;
+assignment of non empty arrays of unequal size was a runtime error).
+
+        
    
+        
    
+
+The  justification for  the  change given  in  N0857 was the "loss  of
+performance [deemed]  only significant  for very simple  operations on
+small arrays or for architectures with very few registers."
+
+        
    
+        
    
+
+Since tiny  arrays on a  limited subset of hardware  architectures are
+likely  to  be  an   exceedingly  rare  case  (despite  the  continued
+popularity of  x86) I  propose to revert  the resolution and  make the
+behavior    of   all   valarray    assignment   operators
+well-defined even  for non-conformal  arrays (i.e., arrays  of unequal
+size).   I have implemented  this change  and measured  no significant
+degradation  in performance in  the common  case (non-empty  arrays of
+equal size).  I  have measured a 50% (and in  some cases even greater)
+speedup  in the  case of  assignments to  empty arrays  versus calling
+resize()  first followed  by  an invocation  of the  copy
+assignment operator.
+
+        
    
+
+
    [
+Bellevue:
+]
    
+
+
+
    
+If no proposed wording by June meeting, this issue should be closed NAD.
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Move resolution 1 to Ready.
+
    
+
    
+Howard: second resolution has been commented out (made invisible).
+Can be brought back on demand.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+        
    
+
+Change 26.6.2.2 [valarray.assign], p1 as follows:
+
+        
    
+        
    
+            
    
+                
+
+valarray<T>& operator=(const valarray<T>& x);
+
+                
+            
    
+            
    
+
+-1- Each element of the *this array is assigned the value
+of  the  corresponding  element   of  the  argument  array.   The
+resulting behavior is undefined if When the length of
+the  argument  array  is  not   equal  to  the  length  of  the  *this
+array.  resizes  *this  to make  the  two
+arrays     the      same     length,     as      if     by     calling
+resize(x.size()), before performing the assignment.
+
+            
    
+        
    
+        
    
+
+And  add a new  paragraph just  below paragraph  1 with  the following
+text:
+
+        
    
+        
    
+            
    
+
+-2- Postcondition: size() == x.size().
+
+            
    
+        
    
+        
    
+
+Also add the following paragraph to 26.6.2.2 [valarray.assign], immediately after p4:
+
+        
    
+        
    
+            
    
+
+-?- When the length,  N of the array referred
+to by the  argument is not equal to  the length of *this,
+the  operator resizes *this  to make  the two  arrays the
+same  length, as if  by calling  resize(N), before
+performing the assignment.
+
+            
    
+        
    
+
+
    [
+pre-Sophia Antipolis, Martin adds the following compromise wording, but
+prefers the original proposed resolution:
+]
    
+
+
+
+
+
+
+
    [
+Kona (2007): Gaby to propose wording for an alternative resolution in
+which you can assign to a valarray of size 0, but not to any other
+valarray whose size is unequal to the right hand side of the assignment.
+]
    
+
+
+
+
+
 
    
 
    634. allocator.address() doesn't work for types overloading operator&
    
-
    Section: 20.8.4.1 [allocator.members] Status: CD1
+
    Section: 20.8.8.1 [allocator.members] Status: CD1
  Submitter: Howard Hinnant Opened: 2007-02-07  Last modified: 2008-09-26
    
 
    View all other issues in [allocator.members].
    
 
    View all issues with CD1 status.
    
@@ -26133,7 +27235,7 @@ will extract unambiguously.]
 
    Discussion:
    
 
 
    
-20.8.4.1 [allocator.members] says:
+20.8.8.1 [allocator.members] says:
 
    
 
    
 
    pointer address(reference x) const;
    
@@ -26145,7 +27247,7 @@ will extract unambiguously.]
 
    
 
 
    
-20.8.4.1 [allocator.members] defines CopyConstructible which currently not
+20.8.8.1 [allocator.members] defines CopyConstructible which currently not
 only defines the semantics of copy construction, but also restricts what an overloaded
 operator& may do.  I believe proposals are in the works (such as concepts
 and rvalue reference) to decouple these two requirements.  Indeed it is not evident
@@ -26168,7 +27270,7 @@ On the other hand, some code truly needs the address of an object, and not a pro
 boost::addressof.
 It appears to me that this would be useful functionality for the default allocator.  Adopting
 this definition for allocator::address would free the standard of requiring
-anything special from types which overload operator&.  Issue 580
+anything special from types which overload operator&.  Issue 580
 is expected to make use of allocator::address mandatory for containers.
 
    
 
@@ -26176,7 +27278,7 @@ is expected to make use of allocator::address mandatory for containers.
 
 
    Proposed resolution:
    
 
    
-Change 20.8.4.1 [allocator.members]:
+Change 20.8.8.1 [allocator.members]:
 
    
 
 
    
@@ -26786,6 +27888,207 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
 
 
 
+
    
+
    659. istreambuf_iterator should have an operator->()
    
+
    Section: 24.6.3 [istreambuf.iterator] Status: WP
+ Submitter: Niels Dekker Opened: 2007-03-25  Last modified: 2009-10-26
    
+
    View all other issues in [istreambuf.iterator].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+Greg Herlihy has clearly demonstrated that a user defined input
+iterator should have an operator->(), even if its
+value type is a built-in type (comp.std.c++, "Re: Should any iterator
+have an operator->() in C++0x?", March 2007).  And as Howard
+Hinnant remarked in the same thread that the input iterator
+istreambuf_iterator doesn't have one, this must be a
+defect!
+
    
+
    
+Based on Greg's example, the following code demonstrates the issue:
+
     #include <iostream> 
+ #include <fstream>
+ #include <streambuf> 
+
+ typedef char C;
+ int main ()
+ {
+   std::ifstream s("filename", std::ios::in);
+   std::istreambuf_iterator<char> i(s);
+
+   (*i).~C();  // This is well-formed...
+   i->~C();  // ... so this should be supported!
+ }
+
    
+
+
    
+Of course, operator-> is also needed when the value_type of
+istreambuf_iterator is a class.
+
    
+
    
+The operator-> could be implemented in various ways.  For instance,
+by storing the current value inside the iterator, and returning its
+address.  Or by returning a proxy, like operator_arrow_proxy, from
+http://www.boost.org/boost/iterator/iterator_facade.hpp
+
    
+
    
+I hope that the resolution of this issue will contribute to getting a
+clear and consistent definition of iterator concepts.
+
    
+
+
    [
+Kona (2007): The proposed resolution is inconsistent because the return
+type of istreambuf_iterator::operator->() is specified to be pointer,
+but the proposed text also states that "operator-> may return a proxy."
+]
    
+
+
+
    [
+Niels Dekker (mailed to Howard Hinnant):
+]
    
+
+
    
+
    
+The proposed resolution does
+not seem inconsistent to me. istreambuf_iterator::operator->() should
+have istreambuf_iterator::pointer as return type, and this return type
+may in fact be a proxy.
+
    
+
    
+AFAIK, the resolution of 445 ("iterator_traits::reference
+unspecified for some iterator categories") implies that for any iterator
+class Iter, the return type of operator->() is Iter::pointer, by
+definition.  I don't think Iter::pointer needs to be a raw pointer.
+
    
+
    
+Still I wouldn't mind if the text "operator-> may return a proxy" would
+be removed from the resolution. I think it's up to the library
+implementation, how to implement istreambuf_iterator::operator->().  As
+longs as it behaves as expected: i->m should have the same effect as
+(*i).m. Even for an explicit destructor call, i->~C().  The main issue
+is just: istreambuf_iterator should have an operator->()!
+
    
+
    
+
+
    [
+2009-04-30 Alisdair adds:
+]
    
+
+
+
    
+Note that operator-> is now a requirement in the InputIterator concept, so
+this issue cannot be ignored or existing valid programs will break when
+compiled with an 0x library.
+
    
+
+
    [
+2009-05-29 Alisdair adds:
+]
    
+
+
+
    
+
    
+I agree with the observation that in principle the type 'pointer' may be a
+proxy, and the words highlighting this are redundant.
+
    
+
    
+However, in the current draught pointer is required to be exactly 'charT *'
+by the derivation from std::iterator.  At a minimum, the 4th parameter of
+this base class template should become unspecified.  That permits the
+introduction of a proxy as a nested class in some further undocumented (not
+even exposition-only) base.
+
    
+
    
+It also permits the istream_iterator approach where the cached value is
+stored in the iterator itself, and the iterator serves as its own proxy for
+post-increment operator++ - removing the need for the existing
+exposition-only nested class proxy.
+
    
+
    
+Note that the current proxy class also has exactly the right properties to
+serve as the pointer proxy too.  This is likely to be a common case where an
+InputIterator does not hold internal state but delegates to another class.
+
    
+
    
+Proposed Resolution:
+
    
+
    
+In addition to the current proposal:
+
    
+
    
+24.6.3 [istreambuf.iterator]
+
    
+
    template<class charT, class traits = char_traits<charT> >
+class istreambuf_iterator
+  : public iterator<input_iterator_tag, charT,
+                    typename traits::off_type, charT* unspecified, charT> {
+
    
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+
    
+Move the additional part into the proposed resolution, and wrap the
+descriptive text in a Note.
+
    
+
    [Howard: done.]
    
+
+
    
+Move to Ready.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Add to the synopsis in 24.6.3 [istreambuf.iterator]:
+
    
+
+
    charT operator*() const;
+pointer operator->() const;
+istreambuf_iterator<charT,traits>& operator++();
+
    
+
+
    
+24.6.3 [istreambuf.iterator]
+
    
+
+
    template<class charT, class traits = char_traits<charT> >
+class istreambuf_iterator
+  : public iterator<input_iterator_tag, charT,
+                    typename traits::off_type, charT* unspecified, charT> {
+
    
+
+
    
+Change 24.6.3 [istreambuf.iterator], p1:
+
    
+
+
    
+The class template istreambuf_iterator reads successive
+characters from the streambuf for which it was constructed.
+operator* provides access to the current input character, if
+any. [Note: operator-> may return a proxy. —
+end note] Each time
+operator++ is evaluated, the iterator advances to the next
+input character. If the end of stream is reached
+(streambuf_type::sgetc() returns traits::eof()), the
+iterator becomes equal to the end of stream iterator value. The default
+constructor istreambuf_iterator() and the constructor
+istreambuf_iterator(0) both construct an end of stream iterator
+object suitable for use as an end-of-range.
+
    
+
+
+
+
+
+
+
 
    
 
    660. Missing Bitwise Operations
    
 
    Section: 20.7 [function.objects] Status: CD1
@@ -27088,7 +28391,7 @@ four characters long, usually three letters and a space.
 
 
    
 
    672. Swappable requirements need updating
    
-
    Section: X [utility.arg.requirements] Status: CD1
+
    Section: 20.2.1 [utility.arg.requirements] Status: CD1
  Submitter: Howard Hinnant Opened: 2007-05-04  Last modified: 2008-09-26
    
 
    View other active issues in [utility.arg.requirements].
    
 
    View all other issues in [utility.arg.requirements].
    
@@ -27179,7 +28482,7 @@ between two different types for the case that one is binding to a user-defined <
 
    Proposed resolution:
    
 
 
    
-Change X [utility.arg.requirements]:
+Change 20.2.1 [utility.arg.requirements]:
 
    
 
 
    
@@ -27248,7 +28551,7 @@ swap to be rvalues).
 
 
    
 
    673. unique_ptr update
    
-
    Section: 20.8.9 [unique.ptr] Status: CD1
+
    Section: 20.8.14 [unique.ptr] Status: CD1
  Submitter: Howard Hinnant Opened: 2007-05-04  Last modified: 2008-09-26
    
 
    View all other issues in [unique.ptr].
    
 
    View all issues with CD1 status.
    
@@ -27370,7 +28673,7 @@ the proposed resolutions below.
 
  • 
 
 
    
-Change 20.8.9.2 [unique.ptr.single]:
+Change 20.8.14.2 [unique.ptr.single]:
 
    
 
 
    template <class T, class D = default_delete<T>> class unique_ptr {
@@ -27381,7 +28684,7 @@ Change 20.8.9.2 [unique.ptr.single]:
 
    
 
 
    
-Change 20.8.9.2.4 [unique.ptr.single.observers]:
+Change 20.8.14.2.4 [unique.ptr.single.observers]:
 
    
 
 
    T& typename add_lvalue_reference<T>::type operator*() const;
@@ -27391,7 +28694,7 @@ Change 20.8.9.2.4 [unique.ptr.single.observers]:
 
 
  • 
 
    
-Change 20.8.9.2 [unique.ptr.single]:
+Change 20.8.14.2 [unique.ptr.single]:
 
    
 
 
    template <class T, class D = default_delete<T>> class unique_ptr {
@@ -27423,7 +28726,7 @@ and CopyAssignable.
 
    
 
 
    
-Change 20.8.9.2.1 [unique.ptr.single.ctor]:
+Change 20.8.14.2.1 [unique.ptr.single.ctor]:
 
    
 
 
    unique_ptr(T* pointer p);
@@ -27463,7 +28766,7 @@ internally stored deleter which was constructed from
 
    
 
 
    
-Change 20.8.9.2.3 [unique.ptr.single.asgn]:
+Change 20.8.14.2.3 [unique.ptr.single.asgn]:
 
    
 
 
    
@@ -27476,7 +28779,7 @@ convertible to T* pointer.
 
    
 
 
    
-Change 20.8.9.2.4 [unique.ptr.single.observers]:
+Change 20.8.14.2.4 [unique.ptr.single.observers]:
 
    
 
 
    
@@ -27486,7 +28789,7 @@ Change 20.8.9.2.4 [unique.ptr.single.observers]:
 
    
 
 
    
-Change 20.8.9.2.5 [unique.ptr.single.modifiers]:
+Change 20.8.14.2.5 [unique.ptr.single.modifiers]:
 
    
 
 
    
@@ -27496,7 +28799,7 @@ Change 20.8.9.2.5 [unique.ptr.single.modifiers]:
 
    
 
 
    
-Change 20.8.9.3 [unique.ptr.runtime]:
+Change 20.8.14.3 [unique.ptr.runtime]:
 
    
 
 
    template <class T, class D> class unique_ptr<T[], D> {
@@ -27516,7 +28819,7 @@ public:
 
    
 
 
    
-Change 20.8.9.3.1 [unique.ptr.runtime.ctor]:
+Change 20.8.14.3.1 [unique.ptr.runtime.ctor]:
 
    
 
 
    
@@ -27535,7 +28838,7 @@ these members. -- end note]
 
    
 
 
    
-Change 20.8.9.3.3 [unique.ptr.runtime.modifiers]:
+Change 20.8.14.3.3 [unique.ptr.runtime.modifiers]:
 
    
 
 
    
@@ -27555,7 +28858,7 @@ templated overload. -- end note]
 
  • 
 
 
    
-Change 20.8.9.2.1 [unique.ptr.single.ctor]:
+Change 20.8.14.2.1 [unique.ptr.single.ctor]:
 
    
 
 
    
@@ -27589,9 +28892,8 @@ required).
 
 
    
 
    674. shared_ptr interface changes for consistency with N1856
    
-
    Section: 20.8.10.2 [util.smartptr.shared] Status: CD1
+
    Section: 20.8.15.2 [util.smartptr.shared] Status: CD1
  Submitter: Peter Dimov Opened: 2007-05-05  Last modified: 2008-09-26
    
-
    View other active issues in [util.smartptr.shared].
    
 
    View all other issues in [util.smartptr.shared].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -27605,7 +28907,7 @@ and to interoperate with unique_ptr as it does with auto_ptr.
 
    Proposed resolution:
    
 
 
    
-Change 20.8.10.2 [util.smartptr.shared] as follows:
+Change 20.8.15.2 [util.smartptr.shared] as follows:
 
    
 
 
    
@@ -27619,7 +28921,7 @@ template<class Y, class D> shared_ptr& operator=(unique_ptr<Y,D>
 
    
 
 
    
-Change 20.8.10.2.1 [util.smartptr.shared.const] as follows:
+Change 20.8.15.2.1 [util.smartptr.shared.const] as follows:
 
    
 
 
    
@@ -27627,7 +28929,7 @@ Change 20.8.10.2.1 [util.smartptr.shared.const] as follows:
 
    
 
 
    
-Add to 20.8.10.2.1 [util.smartptr.shared.const]:
+Add to 20.8.15.2.1 [util.smartptr.shared.const]:
 
    
 
 
    
@@ -27648,7 +28950,7 @@ Add to 20.8.10.2.1 [util.smartptr.shared.const]:
 
    
 
 
    
-Change 20.8.10.2.3 [util.smartptr.shared.assign] as follows:
+Change 20.8.15.2.3 [util.smartptr.shared.assign] as follows:
 
    
 
 
    
@@ -27656,7 +28958,7 @@ Change 20.8.10.2.3 [util.smartptr.shared.assign] as follows:
 
    
 
 
    
-Add to 20.8.10.2.3 [util.smartptr.shared.assign]:
+Add to 20.8.15.2.3 [util.smartptr.shared.assign]:
 
    
 
 
    
@@ -28092,14 +29394,15 @@ Change 23.3.6.2 [vector.capacity], p11:
 
 
    
 
    680. move_iterator operator-> return
    
-
    Section: 24.5.2.1 [move.iterator] Status: CD1
+
    Section: 24.5.3.1 [move.iterator] Status: CD1
  Submitter: Howard Hinnant Opened: 2007-06-11  Last modified: 2008-09-26
    
+
    View all other issues in [move.iterator].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
 move_iterator's operator-> return type pointer
 does not consistently match the type which is returned in the description
-in 24.5.2.2.5 [move.iter.op.ref].
+in 24.5.3.3.5 [move.iter.op.ref].
 
    
 
 
    template <class Iterator>
@@ -28143,7 +29446,7 @@ finds a non-class type, the second solution avoids the issue of an overloaded
 
 
    Proposed resolution:
    
 
    
-Change the synopsis in 24.5.2.1 [move.iterator]:
+Change the synopsis in 24.5.3.1 [move.iterator]:
 
    
 
 
    typedef typename iterator_traits<Iterator>::pointer pointer;
@@ -28267,7 +29570,7 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
 
 
    
 
    685. reverse_iterator/move_iterator difference has invalid signatures
    
-
    Section: 24.5.1.2.19 [reverse.iter.opdiff], 24.5.2.2.14 [move.iter.nonmember] Status: CD1
+
    Section: 24.5.1.3.19 [reverse.iter.opdiff], 24.5.3.3.14 [move.iter.nonmember] Status: CD1
  Submitter: Bo Persson Opened: 2007-06-10  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -28281,7 +29584,7 @@ is possible to compute only if both iterators have the same base
 iterator. The result type is the difference_type of the base iterator. 
 
    
 
    
-In the current draft, the operator is defined as 24.5.1.2.19 [reverse.iter.opdiff] 
+In the current draft, the operator is defined as 24.5.1.3.19 [reverse.iter.opdiff] 
 
    
 
    template<class Iterator1, class Iterator2> 
 typename reverse_iterator<Iterator>::difference_type 
@@ -28299,7 +29602,7 @@ implementation choose one of them? Which one?
 
    
 
    
 The same problem now also appears in operator-() for move_iterator
-24.5.2.2.14 [move.iter.nonmember]. 
+24.5.3.3.14 [move.iter.nonmember]. 
 
    
 
 
@@ -28317,7 +29620,7 @@ Change the synopsis in 24.5.1.1 [reverse.iterator]:
 
    
 
 
    
-Change 24.5.1.2.19 [reverse.iter.opdiff]:
+Change 24.5.1.3.19 [reverse.iter.opdiff]:
 
    
 
 
    
@@ -28335,7 +29638,7 @@ Change 24.5.1.2.19 [reverse.iter.opdiff]:
 
 
 
    
-Change the synopsis in 24.5.2.1 [move.iterator]:
+Change the synopsis in 24.5.3.1 [move.iterator]:
 
    
 
 
    
@@ -28347,7 +29650,7 @@ Change the synopsis in 24.5.2.1 [move.iterator]:
 
    
 
 
    
-Change 24.5.2.2.14 [move.iter.nonmember]:
+Change 24.5.3.3.14 [move.iter.nonmember]:
 
    
 
 
    
@@ -28376,9 +29679,8 @@ goes in.
 
 
    
 
    687. shared_ptr conversion constructor not constrained
    
-
    Section: 20.8.10.2.1 [util.smartptr.shared.const], 20.8.10.3.1 [util.smartptr.weak.const] Status: CD1
+
    Section: 20.8.15.2.1 [util.smartptr.shared.const], 20.8.15.3.1 [util.smartptr.weak.const] Status: CD1
  Submitter: Peter Dimov Opened: 2007-05-10  Last modified: 2009-02-02
    
-
    View other active issues in [util.smartptr.shared.const].
    
 
    View all other issues in [util.smartptr.shared.const].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -28406,7 +29708,7 @@ overload resolution when the pointer types are compatible.
 
 
    Proposed resolution:
    
 
    
-In 20.8.10.2.1 [util.smartptr.shared.const], change:
+In 20.8.15.2.1 [util.smartptr.shared.const], change:
 
    
 
 
    
@@ -28417,7 +29719,7 @@ to T*.
 
    
 
 
    
-In 20.8.10.3.1 [util.smartptr.weak.const], change:
+In 20.8.15.3.1 [util.smartptr.weak.const], change:
 
    
 
 
    
@@ -28774,7 +30076,7 @@ Ready.
 
 
    
 
    693. std::bitset::all() missing
    
-
    Section: 20.3.6 [template.bitset] Status: CD1
+
    Section: 20.3.7 [template.bitset] Status: CD1
  Submitter: Martin Sebor Opened: 2007-06-22  Last modified: 2008-09-26
    
 
    View other active issues in [template.bitset].
    
 
    View all other issues in [template.bitset].
    
@@ -28801,7 +30103,7 @@ the first word with a zero bit).
 
    Proposed resolution:
    
 
    
 Add  a declaration of the new  member function all() to the
-defintion of the bitset template in 20.3.6 [template.bitset], p1,
+defintion of the bitset template in 20.3.7 [template.bitset], p1,
 right above the declaration of any() as shown below:
 
    
 
@@ -28813,7 +30115,7 @@ bool none() const;
 
    
 
 
    
-Add a description of the new member function to the end of 20.3.6.2 [bitset.members] with the following text:
+Add a description of the new member function to the end of 20.3.7.2 [bitset.members] with the following text:
 
    
 
    
 bool all() const;
@@ -28854,7 +30156,7 @@ is onecount() == 0.
 
 
    
 
    694. std::bitset and long long
    
-
    Section: 20.3.6 [template.bitset] Status: CD1
+
    Section: 20.3.7 [template.bitset] Status: CD1
  Submitter: Martin Sebor Opened: 2007-06-22  Last modified: 2008-09-26
    
 
    View other active issues in [template.bitset].
    
 
    View all other issues in [template.bitset].
    
@@ -28895,7 +30197,7 @@ explicit bitset(
 
    
 
    
 
    
-Make a corresponding change in 20.3.6.1 [bitset.cons], p2:
+Make a corresponding change in 20.3.7.1 [bitset.cons], p2:
 
    
 
    
 
    
@@ -28918,7 +30220,7 @@ Additionally, introduce a new member function to_ullong()
 to make  it possible to  convert bitset to values  of the
 new  type. Add  the following  declaration  to the  definition of  the
 template, immediate  after the declaration  of to_ulong()
-in 20.3.6 [template.bitset], p1, as shown below:
+in 20.3.7 [template.bitset], p1, as shown below:
 
    
 
    
 
    // element access:
@@ -28931,7 +30233,7 @@ basic_string<charT, traits, Allocator> to_string() const;
 
    
 
    
 
    
-And add a description of  the new member function to 20.3.6.2 [bitset.members],
+And add a description of  the new member function to 20.3.7.2 [bitset.members],
 below  the  description of  the  existing to_ulong()  (if
 possible), with the following text:
 
    
@@ -29013,6 +30315,227 @@ virtual char do_toupper(char c) const;
 
 
 
+
    
+
    696. istream::operator>>(int&) broken
    
+
    Section: 27.7.1.2.2 [istream.formatted.arithmetic] Status: WP
+ Submitter: Martin Sebor Opened: 2007-06-23  Last modified: 2009-10-26
    
+
    View all other issues in [istream.formatted.arithmetic].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+From message c++std-lib-17897:
+
    
+
    
+The code shown in 27.7.1.2.2 [istream.formatted.arithmetic] as the "as if"
+implementation of the two arithmetic extractors that don't have a
+corresponding num_get interface (i.e., the
+short and int overloads) is subtly buggy in
+how it deals with EOF, overflow, and other similar
+conditions (in addition to containing a few typos).
+
    
+
    
+One problem is that if num_get::get() reaches the EOF
+after reading in an otherwise valid value that exceeds the limits of
+the narrower type (but not LONG_MIN or
+LONG_MAX), it will set err to
+eofbit. Because of the if condition testing for
+(err == 0), the extractor won't set
+failbit (and presumably, return a bogus value to the
+caller).
+
    
+
    
+Another problem with the code is that it never actually sets the
+argument to the extracted value. It can't happen after the call to
+setstate() since the function may throw, so we need to
+show when and how it's done (we can't just punt as say: "it happens
+afterwards"). However, it turns out that showing how it's done isn't
+quite so easy since the argument is normally left unchanged by the
+facet on error except when the error is due to a misplaced thousands
+separator, which causes failbit to be set but doesn't
+prevent the facet from storing the value.
+
    
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+
    
+We believe this part of the Standard has been recently adjusted
+and that this issue was addressed during that rewrite.
+
    
+
    
+Move to NAD.
+
    
+
    
+
+
    [
+2009-05-28 Howard adds:
+]
    
+
+
+
    
+
    
+I've moved this issue from Tentatively NAD to Open.
+
    
+
+
    
+The current wording of
+N2857
+in 22.4.2.1.2 [facet.num.get.virtuals] p3, stage 3 appears to indicate that
+in parsing arithmetic types, the value is always set, but sometimes in addition
+to setting failbit.
+
    
+
+
      
+
    • 
+If there is a range error, the value is set to min or max, else
+
      • 
+
    • 
+if there is a conversion error, the value is set to 0, else
+
      • 
+
    • 
+if there is a grouping error, the value is set to whatever it would be if grouping were ignored, else
+
      • 
+
    • 
+the value is set to its error-free result.
+
      • 
+
    
+
+
    
+However there is a contradictory sentence in 22.4.2.1.2 [facet.num.get.virtuals] p1.
+
    
+
+
    
+27.7.1.2.2 [istream.formatted.arithmetic] should mimic the behavior of 22.4.2.1.2 [facet.num.get.virtuals]
+(whatever we decide that behavior is) for
+int and short, and currently does not.  I believe that the
+correct code fragment should look like:
+
    
+
+
    typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
+iostate err = ios_base::goodbit;
+long lval;
+use_facet<numget>(loc).get(*this, 0, *this, err, lval);
+if (lval < numeric_limits<int>::min())
+{
+  err |= ios_base::failbit;
+  val = numeric_limits<int>::min();
+}
+else if (lval > numeric_limits<int>::max())
+{
+  err |= ios_base::failbit;
+  val = numeric_limits<int>::max();
+}
+else
+  val = static_cast<int>(lval);
+setstate(err);
+
    
+
    
+
+
    [
+2009-07 Frankfurt
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change 22.4.2.1.2 [facet.num.get.virtuals], p1:
+
    
+
+
    
+-1- Effects: Reads characters from in, interpreting them
+according to str.flags(), use_facet<ctype<charT>
+>(loc), and use_facet< numpunct<charT>
+>(loc), where loc is str.getloc(). If an error
+occurs, val is unchanged; otherwise it is set to the resulting value.
+
    
+
+
    
+Change 27.7.1.2.2 [istream.formatted.arithmetic], p2 and p3:
+
    
+
+
    
+
    operator>>(short& val);
+
    
+
    
+
    
+-2- The conversion occurs as if performed by the following code fragment (using the same notation as for 
+the preceding code fragment):
+
    
+
+
    typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
+iostate err = iostate_base::goodbit;
+long lval;
+use_facet<numget>(loc).get(*this, 0, *this, err, lval);
+if (err != 0)
+  ;
+else if (lval < numeric_limits<short>::min()
+  || numeric_limits<short>::max() < lval)
+     err = ios_base::failbit;
+if (lval < numeric_limits<short>::min())
+{
+  err |= ios_base::failbit;
+  val = numeric_limits<short>::min();
+}
+else if (lval > numeric_limits<short>::max())
+{
+  err |= ios_base::failbit;
+  val = numeric_limits<short>::max();
+}
+else
+  val = static_cast<short>(lval);
+setstate(err);
+
    
+
+
    
+
+
    operator>>(int& val);
+
    
+
    
+
    
+-3- The conversion occurs as if performed by the following code fragment (using the same notation as for 
+the preceding code fragment):
+
    
+
+
    typedef num_get<charT,istreambuf_iterator<charT,traits> > numget;
+iostate err = iostate_base::goodbit;
+long lval;
+use_facet<numget>(loc).get(*this, 0, *this, err, lval);
+if (err != 0)
+  ;
+else if (lval < numeric_limits<int>::min()
+  || numeric_limits<int>::max() < lval)
+     err = ios_base::failbit;
+if (lval < numeric_limits<int>::min())
+{
+  err |= ios_base::failbit;
+  val = numeric_limits<int>::min();
+}
+else if (lval > numeric_limits<int>::max())
+{
+  err |= ios_base::failbit;
+  val = numeric_limits<int>::max();
+}
+else
+  val = static_cast<int>(lval);
+setstate(err);
+
    
+
+
    
+
+
    
+
+
+
+
+
 
    
 
    698. system_error needs const char* constructors
    
 
    Section: 19.5.5.1 [syserr.syserr.overview] Status: CD1
@@ -29132,9 +30655,8 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
 
 
    
 
    700. N1856 defines struct identity
    
-
    Section: 20.3.2 [forward] Status: CD1
+
    Section: 20.3.3 [forward] Status: CD1
  Submitter: P.J. Plauger Opened: 2007-07-01  Last modified: 2008-09-26
    
-
    View other active issues in [forward].
    
 
    View all other issues in [forward].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -29149,7 +30671,7 @@ if we could avoid this name clash for backward compatibility.
 
 
    Proposed resolution:
    
 
    
-Change 20.3.2 [forward]:
+Change 20.3.3 [forward]:
 
    
 
 
    
@@ -29206,7 +30728,6 @@ Add the following to the specification of map::at(), 23.4.1.2 [map.acce
 
    705. type-trait decay incompletely specified
    
 
    Section: 20.6.7 [meta.trans.other] Status: CD1
  Submitter: Thorsten Ottosen Opened: 2007-07-08  Last modified: 2008-09-26
    
-
    View other active issues in [meta.trans.other].
    
 
    View all other issues in [meta.trans.other].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -29233,7 +30754,7 @@ Otherwise the  member typedef type equals remove_cv<U
 
    
 
 
    
-In 20.5.2.2 [tuple.creation]/1 change:
+In 20.5.2.4 [tuple.creation]/1 change:
 
    
 
 
    
@@ -29256,15 +30777,15 @@ is X& if Ui equals
 
 
    
 
    706. make_pair() should behave as make_tuple() wrt. reference_wrapper()
    
-
    Section: 20.3.3 [pairs] Status: CD1
+
    Section: 20.3.4 [pairs] Status: CD1
  Submitter: Thorsten Ottosen Opened: 2007-07-08  Last modified: 2008-09-26
    
 
    View other active issues in [pairs].
    
 
    View all other issues in [pairs].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-The current draft has make_pair() in 20.3.3 [pairs]/16
-and make_tuple() in 20.5.2.2 [tuple.creation].
+The current draft has make_pair() in 20.3.4 [pairs]/16
+and make_tuple() in 20.5.2.4 [tuple.creation].
 make_tuple() detects the presence of
 reference_wrapper<X> arguments and "unwraps" the reference in
 such cases. make_pair() would OTOH create a
@@ -29284,8 +30805,8 @@ In 20.3 [utility] change the synopsis for make_pair() to read
 
    • 
 
 
    
-In 20.3.3 [pairs]/16 change the declaration to match the above synopsis.
-Then change the 20.3.3 [pairs]/17 to:
+In 20.3.4 [pairs]/16 change the declaration to match the above synopsis.
+Then change the 20.3.4 [pairs]/17 to:
 
    
 
 
    
@@ -29372,9 +30893,8 @@ Moved from Pending NAD Editorial to Review.  The proposed wording appears to be
 
 
    
 
    710. Missing postconditions
    
-
    Section: 20.8.10.2 [util.smartptr.shared] Status: CD1
+
    Section: 20.8.15.2 [util.smartptr.shared] Status: CD1
  Submitter: Peter Dimov Opened: 2007-08-24  Last modified: 2008-09-26
    
-
    View other active issues in [util.smartptr.shared].
    
 
    View all other issues in [util.smartptr.shared].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -29406,7 +30926,7 @@ editor should consider rewording "If w is the return value...", e. g. as
 
 
    Proposed resolution:
    
 
    
-Add to 20.8.10.2.1 [util.smartptr.shared.const]:
+Add to 20.8.15.2.1 [util.smartptr.shared.const]:
 
    
 
 
    
@@ -29422,7 +30942,7 @@ shall be empty. r.get() == 0.
 
    
 
 
    
-Add to 20.8.10.2.10 [util.smartptr.shared.cast]:
+Add to 20.8.15.2.10 [util.smartptr.shared.cast]:
 
    
 
 
    
@@ -29465,7 +30985,7 @@ the aliasing constructor as follows:
 
    
 
 
    
-Change 20.8.10.2.10 [util.smartptr.shared.cast]:
+Change 20.8.15.2.10 [util.smartptr.shared.cast]:
 
    
 
 
    
@@ -29510,6 +31030,149 @@ in the aliasing constructor postcondition "by reference".
 
 
 
+
    
+
    711. Contradiction in empty shared_ptr
    
+
    Section: 20.8.15.2.5 [util.smartptr.shared.obs] Status: WP
+ Submitter: Peter Dimov Opened: 2007-08-24  Last modified: 2009-10-26
    
+
    View all other issues in [util.smartptr.shared.obs].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+A discussion on
+comp.std.c++
+has identified a contradiction in the shared_ptr specification.
+The note:
+
    
+
+
    
+[ Note: this constructor allows creation of an empty shared_ptr instance with a non-NULL stored pointer.
+-end note ]
+
    
+
+
    
+after the aliasing constructor
+
    
+
+
    template<class Y> shared_ptr(shared_ptr<Y> const& r, T *p);
+
    
+
+
    
+reflects the intent of
+N2351
+to, well, allow the creation of an empty shared_ptr
+with a non-NULL stored pointer.
+
    
+
+
    
+This is contradicted by the second sentence in the Returns clause of 20.8.15.2.5 [util.smartptr.shared.obs]:
+
    
+
+
    
+
    T* get() const;
+
    
+
    
+Returns: the stored pointer. Returns a null pointer if *this is empty.
+
    
+
    
+
+
    [
+Bellevue:
+]
    
+
+
+
    
+
    
+Adopt option 1 and move to review, not ready.
+
    
+
    
+There was a lot of confusion about what an empty shared_ptr is (the term
+isn't defined anywhere), and whether we have a good mental model for how
+one behaves. We think it might be possible to deduce what the definition
+should be, but the words just aren't there. We need to open an issue on
+the use of this undefined term. (The resolution of that issue might
+affect the resolution of issue 711.)
+
    
+
    
+The LWG is getting more uncomfortable with the aliasing proposal (N2351)
+now that we realize some of its implications, and we need to keep an eye
+on it, but there isn't support for removing this feature at this time.
+
    
+
    
+
+
    [
+Sophia Antipolis:
+]
    
+
+
+
    
+
    
+We heard from Peter Dimov, who explained his reason for preferring solution 1.
+
    
+
    
+Because it doesn't seem to add anything. It simply makes the behavior
+for p = 0 undefined. For programmers who don't create empty pointers
+with p = 0, there is no difference. Those who do insist on creating them
+presumably have a good reason, and it costs nothing for us to define the
+behavior in this case.
+
    
+
    
+The aliasing constructor is sharp enough as it is, so "protecting" users
+doesn't make much sense in this particular case.
+
    
+
    
+> Do you have a use case for r being empty and r being non-null? 
+
    
+
    
+I have received a few requests for it from "performance-conscious"
+people (you should be familiar with this mindset) who don't like the
+overhead of allocating and maintaining a control block when a null
+deleter is used to approximate a raw pointer. It is obviously an "at
+your own risk", low-level feature; essentially a raw pointer behind a
+shared_ptr facade.
+
    
+
    
+We could not agree upon a resolution to the issue; some of us thought
+that Peter's description above is supporting an undesirable behavior.
+
    
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+
    
+We favor option 1, move to Ready.
+
    
+
    [
+Howard:  Option 2 commented out for clarity, and can be brought back.
+]
    
+
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+In keeping the N2351 spirit and obviously my preference, change 20.8.15.2.5 [util.smartptr.shared.obs]:
+
    
+
+
    
+
    T* get() const;
+
    
+
    
+Returns: the stored pointer. Returns a null pointer if *this is empty.
+
    
+
    
+
+
+
+
+
+
+
+
 
    
 
    712. seed_seq::size no longer useful
    
 
    Section: 26.5.7.1 [rand.util.seedseq] Status: CD1
@@ -29555,7 +31218,7 @@ The LWG voted to accelerate this issue to Ready status to be voted into the WP a
 
 
    
 
    713. sort() complexity is too lax
    
-
    Section: 25.5.1.1 [sort] Status: CD1
+
    Section: 25.4.1.1 [sort] Status: CD1
  Submitter: Matt Austern Opened: 2007-08-30  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -29577,7 +31240,7 @@ is no reason not to guarantee it in the standard.
 
 
    Proposed resolution:
    
 
    
-In 25.5.1.1 [sort], change the complexity to "O(N log N)", and remove footnote 266:
+In 25.4.1.1 [sort], change the complexity to "O(N log N)", and remove footnote 266:
 
    
 
 
    
@@ -29599,13 +31262,13 @@ If the worst case behavior is important stable_sort() (25.3.1.2) or 
 
    714. search_n complexity is too lax
    
-
    Section: 25.3.12 [alg.search] Status: CD1
+
    Section: 25.2.12 [alg.search] Status: CD1
  Submitter: Matt Austern Opened: 2007-08-30  Last modified: 2008-09-26
    
 
    View all other issues in [alg.search].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-The complexity for search_n (25.3.12 [alg.search] par 7) is specified as "At most
+The complexity for search_n (25.2.12 [alg.search] par 7) is specified as "At most
 (last - first ) * count applications of the corresponding predicate if
 count is positive, or 0 otherwise." This is unnecessarily pessimistic.
 Regardless of the value of count, there is no reason to examine any
@@ -29645,13 +31308,13 @@ template<class ForwardIterator, class Size, class T,
 
 
    
 
    715. minmax_element complexity is too lax
    
-
    Section: 25.5.7 [alg.min.max] Status: CD1
+
    Section: 25.4.7 [alg.min.max] Status: CD1
  Submitter: Matt Austern Opened: 2007-08-30  Last modified: 2008-09-26
    
 
    View all other issues in [alg.min.max].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-The complexity for minmax_element (25.5.7 [alg.min.max] par 16) says "At most max(2 *
+The complexity for minmax_element (25.4.7 [alg.min.max] par 16) says "At most max(2 *
 (last - first ) - 2, 0) applications of the corresponding comparisons",
 i.e. the worst case complexity is no better than calling min_element and
 max_element separately. This is gratuitously inefficient. There is a
@@ -29662,7 +31325,7 @@ well known technique that does better: see section 9.1 of CLRS
 
 
    Proposed resolution:
    
 
    
-Change 25.5.7 [alg.min.max] to:
+Change 25.4.7 [alg.min.max] to:
 
    
 
 
    
@@ -29696,11 +31359,82 @@ corresponding comparisons predicate, where N is dis
 
 
 
+
    
+
    716. Production in [re.grammar] not actually modified
    
+
    Section: 28.13 [re.grammar] Status: WP
+ Submitter: Stephan T. Lavavej Opened: 2007-08-31  Last modified: 2009-10-26
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+TR1 7.13 [tr.re.grammar]/3 and C++0x WP 28.13 [re.grammar]/3 say:
+
    
+
+
    
+
    
+The following productions within the ECMAScript grammar are modified as follows:
+
    
+
+
    CharacterClass ::
+[ [lookahead ∉ {^}] ClassRanges ]
+[ ^ ClassRanges ]
+
    
+
+
    
+
+
    
+This definition for CharacterClass appears to be exactly identical to that in ECMA-262.
+
    
+
+
    
+Was an actual modification intended here and accidentally omitted, or was this production accidentally included?
+
    
+
+
    [
+Batavia (2009-05):
+]
    
+
+
    
+
    
+We agree that what is specified is identical to what ECMA-262 specifies.
+Pete would like to take a bit of time to assess whether we had intended,
+but failed, to make a change.
+It would also be useful to hear from John Maddock on the issue.
+
    
+
    
+Move to Open.
+
    
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Remove this mention of the CharacterClass production.
+
    
+
+
    CharacterClass ::
+[ [lookahead ∉ {^}] ClassRanges ]
+[ ^ ClassRanges ]
+
    
+
+
+
+
+
+
 
    
 
    720. Omissions in constexpr usages
    
-
    Section: 23.3.1 [array], 20.3.6 [template.bitset] Status: CD1
+
    Section: 23.3.1 [array], 20.3.7 [template.bitset] Status: CD1
  Submitter: Daniel Krügler Opened: 2007-08-25  Last modified: 2008-09-26
    
-
    View other active issues in [array].
    
 
    View all other issues in [array].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -29761,12 +31495,12 @@ In order to have a consistent working paper, Alisdair and Daniel produced a new
 
    • 
 
 
  • 
-
    In the class template definition of 20.3.6 [template.bitset]/p. 1 change
    
+
    In the class template definition of 20.3.7 [template.bitset]/p. 1 change
    
 
    constexpr bool test(size_t pos ) const;
 
    
 
 
    
-and in 20.3.6.2 [bitset.members] change
+and in 20.3.7.2 [bitset.members] change
 
    
 
 
    constexpr bool test(size_t pos ) const;
@@ -29811,6 +31545,145 @@ just after the existing entry nan.
 
 
 
+
    
+
    723. basic_regex should be moveable
    
+
    Section: 28.8 [re.regex] Status: WP
+ Submitter: Daniel Krügler Opened: 2007-08-29  Last modified: 2009-10-26
    
+
    View all other issues in [re.regex].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
+
    Addresses UK 316
    
+
+
    
+According to the current state of the standard draft, the class
+template basic_regex, as described in 28.8 [re.regex]/3, is
+neither MoveConstructible nor MoveAssignable.
+IMO it should be, because typical regex state machines tend
+to have a rather large data quantum and I have seen several
+use cases, where a factory function returns regex values,
+which would take advantage of moveabilities.
+
    
+
+
    [
+Sophia Antipolis:
+]
    
+
+
+
    
+Needs wording for the semantics, the idea is agreed upon.
+
    
+
+
    [
+Post Summit Daniel updated wording to reflect new "swap rules".
+]
    
+
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+In the class definition of basic_regex, just below 28.8 [re.regex]/3,
+perform the following changes:
+
    
+
+
      
+
    1. 
+
      
+Just after basic_regex(const basic_regex&); insert:
+
      
+
+
      basic_regex(basic_regex&&);
+
      
+
      2. 
+
    2. 
+
      
+Just after basic_regex& operator=(const basic_regex&); insert:
+
      
+
      basic_regex& operator=(basic_regex&&);
+
      
+
      3. 
+
    3. 
+
      
+Just after basic_regex& assign(const basic_regex& that); insert:
+
      
+
      basic_regex& assign(basic_regex&& that);
+
      
+
      4. 
+
    4. 
+
      
+In 28.8.2 [re.regex.construct], just after p.11 add the following
+new member definition:
+
      
+
      basic_regex(basic_regex&& e);
+
      
+
      
+
      
+Effects: Move-constructs a basic_regex instance from e.
+
      
+
      
+Postconditions: flags() and mark_count() return e.flags() and
+e.mark_count(), respectively,
+that e had before construction, leaving
+e in a valid state with an unspecified value.
+
      
+
      
+Throws: nothing.
+
      
+
      
+
      
+
      5. 
+
    5. 
+
      
+Also in 28.8.2 [re.regex.construct], just after p.18 add the
+following new member definition:
+
      
+
+
      basic_regex& operator=(basic_regex&& e);
+
      
+
      
+Effects: Returns the result of assign(std::move(e)).
+
      
+
      
+
      6. 
+
    6. 
+
      
+In 28.8.3 [re.regex.assign], just after p. 2 add the following new
+member definition:
+
      
+
      basic_regex& assign(basic_regex&& rhs);
+
      
+
      
+
      
+Effects: Move-assigns a basic_regex instance from rhs and returns *this.
+
      
+
      
+Postconditions: flags() and mark_count() return rhs.flags()
+and rhs.mark_count(), respectively, that
+rhs had before assignment, leaving rhs
+in a valid state with an unspecified value.
+
      
+
      
+Throws: nothing.
+
      
+
      
+
      
+
      7. 
+
    
+
+
+
+
+
 
    
 
    728. Problem in [rand.eng.mers]/6
    
 
    Section: 26.5.3.2 [rand.eng.mers] Status: CD1
@@ -30120,7 +31993,7 @@ straw poll unanimous move to Ready.
 
 
    Proposed resolution:
    
 
    
-Change the synopsis under 20.8.9 [unique.ptr] p2:
+Change the synopsis under 20.8.14 [unique.ptr] p2:
 
    
 
 
    ...
@@ -30151,7 +32024,7 @@ and its subsections:  [unique.ptr.compiletime.dtor],  [unique.ptr.compiletime.ob
 
 
    
 
    743. rvalue swap for shared_ptr
    
-
    Section: 20.8.10.2.9 [util.smartptr.shared.spec] Status: CD1
+
    Section: 20.8.15.2.9 [util.smartptr.shared.spec] Status: CD1
  Submitter: Howard Hinnant Opened: 2007-10-10  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -30193,7 +32066,7 @@ Adopt issue as written.
 
 
    Proposed resolution:
    
 
    
-Change the synopsis in 20.8.10.2 [util.smartptr.shared]:
+Change the synopsis in 20.8.15.2 [util.smartptr.shared]:
 
    
 
 
    void swap(shared_ptr&& r);
@@ -30204,14 +32077,14 @@ template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>
 
    
 
 
    
-Change 20.8.10.2.4 [util.smartptr.shared.mod]:
+Change 20.8.15.2.4 [util.smartptr.shared.mod]:
 
    
 
 
    void swap(shared_ptr&& r);
 
    
 
 
    
-Change 20.8.10.2.9 [util.smartptr.shared.spec]:
+Change 20.8.15.2.9 [util.smartptr.shared.spec]:
 
    
 
 
    template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b);
@@ -30350,7 +32223,7 @@ Accept the broad view and move to ready
 
 
    Proposed resolution:
    
 
    
-Add the following exemption clause to 17.6.4.10 [res.on.exception.handling]:
+Add the following exemption clause to 17.6.4.11 [res.on.exception.handling]:
 
    
 
 
    
@@ -30436,14 +32309,13 @@ throw any exceptions or T is an array of such a class type.
 
 
    
 
    752. Allocator complexity requirement
    
-
    Section: X [allocator.requirements] Status: WP
+
    Section: 20.2.2 [allocator.requirements] Status: WP
  Submitter: Hans Boehm Opened: 2007-10-11  Last modified: 2009-03-09
    
-
    View other active issues in [allocator.requirements].
    
 
    View all other issues in [allocator.requirements].
    
 
    View all issues with WP status.
    
 
    Discussion:
    
 
    
-Did LWG recently discuss X [allocator.requirements]-2, which states that "All the operations
+Did LWG recently discuss 20.2.2 [allocator.requirements]-2, which states that "All the operations
 on the allocators are expected to be amortized constant time."?
 
    
 
    
@@ -30466,7 +32338,7 @@ the constants, not the asymptotic complexity.
 
 
    Proposed resolution:
    
 
    
-Change X [allocator.requirements]/2:
+Change 20.2.2 [allocator.requirements]/2:
 
    
 
 
    
@@ -30484,7 +32356,7 @@ requirements on allocator types.
 
 
    
 
    753. Move constructor in draft
    
-
    Section: X [utility.arg.requirements] Status: WP
+
    Section: 20.2.1 [utility.arg.requirements] Status: WP
  Submitter: Yechezkel Mett Opened: 2007-10-14  Last modified: 2009-03-09
    
 
    View other active issues in [utility.arg.requirements].
    
 
    View all other issues in [utility.arg.requirements].
    
@@ -30496,7 +32368,7 @@ places, but doesn't seem to define it.
 
    
 
 
    
-MoveConstructible requirements are defined in Table 33 in X [utility.arg.requirements] as
+MoveConstructible requirements are defined in Table 33 in 20.2.1 [utility.arg.requirements] as
 follows:
 
    
 
@@ -30704,9 +32576,8 @@ allow latitude for implementation-specific optimizations.
 
 
    
 
    758. shared_ptr and nullptr
    
-
    Section: 20.8.10.2 [util.smartptr.shared] Status: WP
+
    Section: 20.8.15.2 [util.smartptr.shared] Status: WP
  Submitter: Joe Gottman Opened: 2007-10-31  Last modified: 2009-03-09
    
-
    View other active issues in [util.smartptr.shared].
    
 
    View all other issues in [util.smartptr.shared].
    
 
    View all issues with WP status.
    
 
    Discussion:
    
@@ -30803,7 +32674,7 @@ The following wording changes are less intrusive:
 
    
 
 
    
-In 20.8.10.2.1 [util.smartptr.shared.const], add:
+In 20.8.15.2.1 [util.smartptr.shared.const], add:
 
    
 
 
    shared_ptr(nullptr_t);
@@ -30882,7 +32753,7 @@ Disposition: move to review. The review should check the wording in the then-cur
 
 
    Proposed resolution:
    
 
    
-In 20.8.10.2 [util.smartptr.shared] p4, add to the definition/synopsis
+In 20.8.15.2 [util.smartptr.shared] p4, add to the definition/synopsis
 of shared_ptr:
 
    
 
@@ -30899,7 +32770,7 @@ template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 
    
 
 
    
-In 20.8.10.2.1 [util.smartptr.shared.const] add:
+In 20.8.15.2.1 [util.smartptr.shared.const] add:
 
    
 
 
    template<class D> shared_ptr(nullptr_t p, D d);
@@ -30915,11 +32786,11 @@ template<class Y, class D, class A> shared_ptr(Y* p, D d, A a);
 
    
 
 
    
-(reusing the following paragraphs 20.8.10.2.1 [util.smartptr.shared.const]/9-13 that speak of p.)
+(reusing the following paragraphs 20.8.15.2.1 [util.smartptr.shared.const]/9-13 that speak of p.)
 
    
 
 
    
-In 20.8.10.2.1 [util.smartptr.shared.const]/10,  change
+In 20.8.15.2.1 [util.smartptr.shared.const]/10,  change
 
    
 
 
    
@@ -31053,7 +32924,7 @@ Bellevue:  Editorial note: the "(unique)" differs from map.
 
 
    
 
    762. std::unique_ptr requires complete type?
    
-
    Section: 20.8.9 [unique.ptr] Status: CD1
+
    Section: 20.8.14 [unique.ptr] Status: CD1
  Submitter: Daniel Krügler Opened: 2007-11-30  Last modified: 2008-09-26
    
 
    View all other issues in [unique.ptr].
    
 
    View all issues with CD1 status.
    
@@ -31099,7 +32970,7 @@ The specialization unique_ptr<T[]> has some more restrictive cons
 type-completeness on T than unique_ptr<T>. The following proposed wordings
 try to cope with that. If the committee sees less usefulness on relaxed
 constraints on unique_ptr<T[]>, the alternative would be to stop this relaxation
-e.g. by adding one further bullet to 20.8.9.3 [unique.ptr.runtime]/1:
+e.g. by adding one further bullet to 20.8.14.3 [unique.ptr.runtime]/1:
 "T shall be a complete type, if used as template argument of
 unique_ptr<T[], D>
 
    
@@ -31118,7 +32989,7 @@ current specification of unique_ptr.
 
      
 
    1. 
 
      
-In 20.8.9 [unique.ptr]/2 add as the last sentence to the existing para:
+In 20.8.14 [unique.ptr]/2 add as the last sentence to the existing para:
 
      
 
 
      
@@ -31137,7 +33008,7 @@ function. -- end note ]
 
 
    2. 
 
      
-20.8.9.2.1 [unique.ptr.single.ctor]/1: No changes necessary.
+20.8.14.2.1 [unique.ptr.single.ctor]/1: No changes necessary.
 
      
 
 
      
@@ -31151,7 +33022,7 @@ The current wording says just this.
 
 
    3. 
 
      
-In 20.8.9.2.1 [unique.ptr.single.ctor]/5 change the requires clause to say:
+In 20.8.14.2.1 [unique.ptr.single.ctor]/5 change the requires clause to say:
 
      
 
 
      
@@ -31188,7 +33059,7 @@ again requires Completeness of Y, if !SameType<X, Y>
 
 
    4. 
 
      
-Merge 20.8.9.2.1 [unique.ptr.single.ctor]/12+13 thereby removing the sentence
+Merge 20.8.14.2.1 [unique.ptr.single.ctor]/12+13 thereby removing the sentence
 of 12, but transferring the "requires" to 13:
 
      
 
@@ -31207,10 +33078,10 @@ pointer and the D deleter are well-formed and well-defined.
 
      5. 
 
 
    5. 
-20.8.9.2.1 [unique.ptr.single.ctor]/17: No changes necessary.
+20.8.14.2.1 [unique.ptr.single.ctor]/17: No changes necessary.
 
      6. 
 
    6. 
-
      20.8.9.2.1 [unique.ptr.single.ctor]/21:
      
+
      20.8.14.2.1 [unique.ptr.single.ctor]/21:
      
 
 
      
 Requires: If D is not a reference type, construction of
@@ -31233,7 +33104,7 @@ e.g. "U shall be a complete type."
 
 
    7. 
 
      
-20.8.9.2.2 [unique.ptr.single.dtor]: Just before p1 add a new paragraph:
+20.8.14.2.2 [unique.ptr.single.dtor]: Just before p1 add a new paragraph:
 
      
 
      
 
      
@@ -31252,7 +33123,7 @@ type-completeness of T is delegated to this expression.
 
 
    8. 
 
      
-20.8.9.2.3 [unique.ptr.single.asgn]/1: No changes necessary, except the
+20.8.14.2.3 [unique.ptr.single.asgn]/1: No changes necessary, except the
 current editorial issue, that "must shall" has to be changed to
 "shall", but this change is not a special part of this resolution.
 
      
@@ -31266,7 +33137,7 @@ further requirements on the requirements of the effects clause
 
 
    9. 
 
      
-20.8.9.2.3 [unique.ptr.single.asgn]/6:
+20.8.14.2.3 [unique.ptr.single.asgn]/6:
 
      
 
 
      
@@ -31287,7 +33158,7 @@ is true, see (6)+(8).
 
 
    10. 
 
      
-20.8.9.2.3 [unique.ptr.single.asgn]/11: No changes necessary.
+20.8.14.2.3 [unique.ptr.single.asgn]/11: No changes necessary.
 
      
 
      [
 N.B.: Delegation to requirements of effects clause is sufficient.
@@ -31296,7 +33167,7 @@ N.B.: Delegation to requirements of effects clause is sufficient.
 
      11. 
 
 
    11. 
-20.8.9.2.4 [unique.ptr.single.observers]/1+4+7+9+11:
+20.8.14.2.4 [unique.ptr.single.observers]/1+4+7+9+11:
 
      12. 
 
 
      
@@ -31307,12 +33178,12 @@ N.B.: Delegation to requirements of effects clause is sufficient.
 
      
 
 
    12. 
-20.8.9.2.5 [unique.ptr.single.modifiers]/1: No changes necessary.
+20.8.14.2.5 [unique.ptr.single.modifiers]/1: No changes necessary.
 
      13. 
 
 
    13. 
 
      
-20.8.9.2.5 [unique.ptr.single.modifiers]/4: Just before p. 4 add a new paragraph:
+20.8.14.2.5 [unique.ptr.single.modifiers]/4: Just before p. 4 add a new paragraph:
 
      
 
      
 Requires: The expression get_deleter()(get()) shall be well-formed,
@@ -31321,12 +33192,12 @@ shall have well-defined behavior, and shall not throw exceptions.
 
      14. 
 
 
    14. 
-20.8.9.2.5 [unique.ptr.single.modifiers]/7: No changes necessary.
+20.8.14.2.5 [unique.ptr.single.modifiers]/7: No changes necessary.
 
      15. 
 
 
    15. 
 
      
-20.8.9.3 [unique.ptr.runtime]: Add one additional bullet on paragraph 1:
+20.8.14.3 [unique.ptr.runtime]: Add one additional bullet on paragraph 1:
 
      
 
 
      
@@ -31358,9 +33229,8 @@ post Bellevue: Daniel provided revised wording.
 
 
      
 
      765. more on iterator validity
      
-
      Section: 24.2 [iterator.concepts] Status: WP
+
      Section: X [iterator.concepts] Status: WP
  Submitter: Martin Sebor Opened: 2007-12-14  Last modified: 2009-07-18
      
-
      View other active issues in [iterator.concepts].
      
 
      View all other issues in [iterator.concepts].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -31794,13 +33664,13 @@ Change the synopsis in 29.5.3 [atomics.types.generic]:
 
 
      
 
      769. std::function should use nullptr_t instead of "unspecified-null-pointer-type"
      
-
      Section: 20.7.16.2 [func.wrap.func] Status: CD1
+
      Section: 20.7.15.2 [func.wrap.func] Status: CD1
  Submitter: Daniel Krügler Opened: 2008-01-10  Last modified: 2008-09-26
      
 
      View all other issues in [func.wrap.func].
      
 
      View all issues with CD1 status.
      
 
      Discussion:
      
 
      
-N2461 already replaced in 20.7.16.2 [func.wrap.func] it's originally proposed
+N2461 already replaced in 20.7.15.2 [func.wrap.func] it's originally proposed
 (implicit) conversion operator to "unspecified-bool-type" by the new
 explicit bool conversion, but the inverse conversion should also
 use the new std::nullptr_t type instead of "unspecified-null-pointer-
@@ -31825,7 +33695,7 @@ template<class R, class... ArgTypes>
 
    
 
 
    
-In the class function synopsis of 20.7.16.2 [func.wrap.func] replace
+In the class function synopsis of 20.7.15.2 [func.wrap.func] replace
 
    
 
 
    function(unspecified-null-pointer-type nullptr_t);
@@ -31834,7 +33704,7 @@ function& operator=(unspecified-null-pointer-type nullptr_t<
 
    
 
 
    
-In 20.7.16.2 [func.wrap.func], "Null pointer comparisons" replace:
+In 20.7.15.2 [func.wrap.func], "Null pointer comparisons" replace:
 
    
 
 
    template <class R, class... ArgTypes>
@@ -31848,7 +33718,7 @@ template <class R, class... ArgTypes>
 
    
 
 
    
-In 20.7.16.2.1 [func.wrap.func.con], replace
+In 20.7.15.2.1 [func.wrap.func.con], replace
 
    
 
 
    function(unspecified-null-pointer-type nullptr_t);
@@ -31857,7 +33727,7 @@ function& operator=(unspecified-null-pointer-type nullptr_t<
 
    
 
 
    
-In 20.7.16.2.6 [func.wrap.func.nullptr], replace
+In 20.7.15.2.6 [func.wrap.func.nullptr], replace
 
    
 
 
    template <class R, class... ArgTypes>
@@ -31883,7 +33753,7 @@ template <class R, class... ArgTypes>
 
 
    
 
    770. std::function should use rvalue swap
    
-
    Section: 20.7.16 [func.wrap] Status: CD1
+
    Section: 20.7.15 [func.wrap] Status: CD1
  Submitter: Daniel Krügler Opened: 2008-01-10  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -31909,14 +33779,14 @@ template<class R, class... ArgTypes>
 
    
 
 
    
-In 20.7.16.2 [func.wrap.func] class function definition, change
+In 20.7.15.2 [func.wrap.func] class function definition, change
 
    
 
 
    void swap(function&&);
 
    
 
 
    
-In 20.7.16.2 [func.wrap.func], just below of
+In 20.7.15.2 [func.wrap.func], just below of
 
    
 
 
    template <class R, class... ArgTypes>
@@ -31928,14 +33798,14 @@ template <class R, class... ArgTypes>
 
    
 
 
    
-In 20.7.16.2.2 [func.wrap.func.mod] change
+In 20.7.15.2.2 [func.wrap.func.mod] change
 
    
 
 
    void swap(function&& other);
 
    
 
 
    
-In 20.7.16.2.7 [func.wrap.func.alg] add the two overloads
+In 20.7.15.2.7 [func.wrap.func.alg] add the two overloads
 
    
 
 
    template<class R, class... ArgTypes>
@@ -32096,7 +33966,7 @@ character buffer of sufficient size.
 
 
    
 
    775. Tuple indexing should be unsigned?
    
-
    Section: 20.5.2.3 [tuple.helper] Status: CD1
+
    Section: 20.5.2.5 [tuple.helper] Status: CD1
  Submitter: Alisdair Meredith Opened: 2008-01-16  Last modified: 2008-09-26
    
 
    View other active issues in [tuple.helper].
    
 
    View all other issues in [tuple.helper].
    
@@ -32152,7 +34022,7 @@ template<intsize_t I, class T1, class T2>
   const Ptypename tuple_element<I, std::pair<T1, T2> >::type & get(const std::pair<T1, T2>&);
 
    
 
    
-Update 20.3.3 [pairs] Pairs
+Update 20.3.4 [pairs] Pairs
 
    
 
    template<intsize_t I, class T1, class T2>
   Ptypename tuple_element<I, std::pair<T1, T2> >::type & get(pair<T1, T2>&);
@@ -32184,7 +34054,7 @@ template <intsize_t I, class ... types>
 
    
 
 
    
-Update 20.5.2.3 [tuple.helper] Tuple helper classes
+Update 20.5.2.5 [tuple.helper] Tuple helper classes
 
    
 
    template <intsize_t I, class... Types>
 class tuple_element<I, tuple<Types...> > {
@@ -32198,7 +34068,7 @@ public:
 2 Type: TI is the type of the Ith element of Types, where indexing is zero-based.
 
    
 
    
-Update 20.5.2.4 [tuple.elem] Element access
+Update 20.5.2.6 [tuple.elem] Element access
 
    
 
    template <intsize_t I, class... types >
 typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>& t);
@@ -32286,7 +34156,6 @@ for pair is also unnecessary.
 
    776. Undescribed assign function of std::array
    
 
    Section: 23.3.1 [array] Status: CD1
  Submitter: Daniel Krügler Opened: 2008-01-20  Last modified: 2008-09-26
    
-
    View other active issues in [array].
    
 
    View all other issues in [array].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -32306,7 +34175,7 @@ be derived by those.
 
 
    
 I found only one reference to this function in the issue list,
-588 where the question is raised:
+588 where the question is raised:
 
    
 
 
    
@@ -32380,7 +34249,6 @@ Set state to Review given substitution of "fill" for "assign".
 
    777. Atomics Library Issue
    
 
    Section: 29.6 [atomics.types.operations] Status: CD1
  Submitter: Lawrence Crowl Opened: 2008-01-21  Last modified: 2008-09-26
    
-
    View other active issues in [atomics.types.operations].
    
 
    View all other issues in [atomics.types.operations].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -32453,7 +34321,7 @@ C A::load(memory_order order = memory_order_seq_cst) const volatile;
 
 
    
 
    778. std::bitset does not have any constructor taking a string literal
    
-
    Section: 20.3.6.1 [bitset.cons] Status: CD1
+
    Section: 20.3.7.1 [bitset.cons] Status: CD1
  Submitter: Thorsten Ottosen Opened: 2008-01-24  Last modified: 2008-09-26
    
 
    View all other issues in [bitset.cons].
    
 
    View all issues with CD1 status.
    
@@ -32479,14 +34347,14 @@ to std::bitset.
 
 
    Proposed resolution:
    
 
    
-Add to synopsis in 20.3.6 [template.bitset]
+Add to synopsis in 20.3.7 [template.bitset]
 
    
 
 
    explicit bitset( const char* str );
 
    
 
 
    
-Add to synopsis in 20.3.6.1 [bitset.cons]
+Add to synopsis in 20.3.7.1 [bitset.cons]
 
    
 
 
    explicit bitset( const char* str );
@@ -32503,7 +34371,7 @@ Add to synopsis in 20.3.6.1 [bitset.cons]
 
 
    
 
    779. Resolution of #283 incomplete
    
-
    Section: 25.4.8 [alg.remove] Status: CD1
+
    Section: 25.3.8 [alg.remove] Status: CD1
  Submitter: Daniel Krügler Opened: 2008-01-25  Last modified: 2008-09-26
    
 
    View all other issues in [alg.remove].
    
 
    View all issues with CD1 status.
    
@@ -32517,7 +34385,7 @@ which seems to be an oversight.
 
 
    Proposed resolution:
    
 
    
-In 25.4.8 [alg.remove]/p.6, replace the N2461 requires clause with:
+In 25.3.8 [alg.remove]/p.6, replace the N2461 requires clause with:
 
    
 
 
    
@@ -32862,12 +34730,12 @@ terminated thread that can no longer be joined.
 
 
    
 
    787. complexity of binary_search
    
-
    Section: 25.5.3.4 [binary.search] Status: CD1
+
    Section: 25.4.3.4 [binary.search] Status: CD1
  Submitter: Daniel Krügler Opened: 2007-09-08  Last modified: 2008-09-26
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-In 25.5.3.4 [binary.search]/3 the complexity of binary_search is described as
+In 25.4.3.4 [binary.search]/3 the complexity of binary_search is described as
 
    
 
 
    
@@ -32903,7 +34771,7 @@ cares about it, he'll send an issue to Howard.
 
 
    Proposed resolution:
    
 
    
-Change 25.5.3.4 [binary.search]/3
+Change 25.4.3.4 [binary.search]/3
 
    
 
 
    
@@ -32914,6 +34782,125 @@ Change 25.5.3.4 [binary.search]/3
 
 
 
+
    
+
    788. ambiguity in [istream.iterator]
    
+
    Section: 24.6.1 [istream.iterator] Status: WP
+ Submitter: Martin Sebor Opened: 2008-02-06  Last modified: 2009-10-26
    
+
    View all other issues in [istream.iterator].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
+
    Addresses UK 287
    
+
+
    
+
    
+It is not clear what the initial state of an istream_iterator should be. Is
+_value_ initialized by reading the stream, or default/value initialized? If
+it is initialized by reading the stream, what happens if the initialization
+is deferred until first dereference, when ideally the iterator value should
+have been that of an end-of-stream iterator which is not safely
+dereferencable?
+
    
+
+
    
+Recommendation: Specify _value_ is initialized by reading the stream, or
+the iterator takes on the end-of-stream value if the stream is empty.
+
    
+
    
+
+
    
+The description of how an istream_iterator object becomes an
+end-of-stream iterator is a) ambiguous and b) out of date WRT
+issue 468:
+
    
+
+
    
+istream_iterator reads (using operator>>) successive elements from the
+input stream for which it was constructed. After it is constructed, and
+every time ++ is used, the iterator reads and stores a value of T. If
+the end of stream is reached (operator void*() on the stream returns
+false), the iterator becomes equal to the end-of-stream iterator value.
+The constructor with no arguments istream_iterator() always constructs
+an end of stream input iterator object, which is the only legitimate
+iterator to be used for the end condition. The result of operator* on an
+end of stream is not defined. For any other iterator value a const T& is
+returned. The result of operator-> on an end of stream is not defined.
+For any other iterator value a const T* is returned. It is impossible to
+store things into istream iterators. The main peculiarity of the istream
+iterators is the fact that ++ operators are not equality preserving,
+that is, i == j does not guarantee at all that ++i == ++j. Every time ++
+is used a new value is read.
+
    
+
+
    
+istream::operator void*() returns null if istream::fail() is true,
+otherwise non-null. istream::fail() returns true if failbit or
+badbit is set in rdstate(). Reaching the end of stream doesn't
+necessarily imply that failbit or badbit is set (e.g., after
+extracting an int from stringstream("123") the stream object will
+have reached the end of stream but fail() is false and operator
+void*() will return a non-null value).
+
    
+
+
    
+Also I would prefer to be explicit about calling fail() here
+(there is no operator void*() anymore.)
+
    
+
+
    [
+Summit:
+]
    
+
+
+
    
+Moved from Ready to Open for the purposes of using this issue to address NB UK 287.
+Martin to handle.
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+
    
+This improves the wording.
+
    
+
    
+Move to Ready.
+
    
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Change 24.6.1 [istream.iterator]/1:
+
    
+
+
    
+istream_iterator reads (using operator>>) successive elements from the
+input stream for which it was constructed. After it is constructed, and
+every time ++ is used, the iterator reads and stores a value of T. If
+the end of stream is reached the iterator fails to read and store a value of T
+(operator void*() fail() on the stream returns
+false true), the iterator becomes equal to the end-of-stream iterator value.
+The constructor with no arguments istream_iterator() always constructs
+an end of stream input iterator object, which is the only legitimate
+iterator to be used for the end condition. The result of operator* on an
+end of stream is not defined. For any other iterator value a const T& is
+returned. The result of operator-> on an end of stream is not defined.
+For any other iterator value a const T* is returned. It is impossible to
+store things into istream iterators. The main peculiarity of the istream
+iterators is the fact that ++ operators are not equality preserving,
+that is, i == j does not guarantee at all that ++i == ++j. Every time ++
+is used a new value is read.
+
    
+
+
+
+
+
 
    
 
    789. xor_combine_engine(result_type) should be explicit
    
 
    Section: X [rand.adapt.xor] Status: CD1
@@ -32980,7 +34967,7 @@ b) If firstB == lastB or the sequence w has the length ze
 
 
    
 
    798. Refactoring of binders lead to interface breakage
    
-
    Section: D.8 [depr.lib.binders] Status: CD1
+
    Section: D.9 [depr.lib.binders] Status: CD1
  Submitter: Daniel Krügler Opened: 2008-02-14  Last modified: 2008-09-26
    
 
    View all other issues in [depr.lib.binders].
    
 
    View all issues with CD1 status.
    
@@ -32988,7 +34975,7 @@ b) If firstB == lastB or the sequence w has the length ze
 
    
 N2521
 and its earlier predecessors have moved the old binders from
-[lib.binders] to D.8 [depr.lib.binders] thereby introducing some renaming
+[lib.binders] to D.9 [depr.lib.binders] thereby introducing some renaming
 of the template parameter names (Operation -> Fn). During this
 renaming process the protected data member op was also renamed to
 fn, which seems as an unnecessary interface breakage to me - even if
@@ -32998,7 +34985,7 @@ this user access point is probably rarely used.
 
 
    Proposed resolution:
    
 
    
-Change D.8.1 [depr.lib.binder.1st]:
+Change D.9.1 [depr.lib.binder.1st]:
 
    
 
 
    
@@ -33030,7 +35017,7 @@ public:
 
    
 
 
    
-Change D.8.3 [depr.lib.binder.2nd]:
+Change D.9.3 [depr.lib.binder.2nd]:
 
    
 
 
    
@@ -33076,8 +35063,8 @@ public:
 
      
 
    1. 
 
      
-19.5.2.2 [syserr.errcode.overview]/1, class error_code and
-19.5.3.2 [syserr.errcondition.overview]/, class error_condition synopses
+19.5.2.1 [syserr.errcode.overview]/1, class error_code and
+19.5.3.1 [syserr.errcondition.overview]/, class error_condition synopses
 declare an expository data member cat_:
 
      
 
      const error_category& cat_; // exposition only
@@ -33092,7 +35079,7 @@ The classes are not (Copy)Assignable, which is probably not the intent.
 
      2. 
 
    2. 
 The post conditions of all modifiers from
-19.5.2.4 [syserr.errcode.modifiers] and 19.5.3.4 [syserr.errcondition.modifiers], resp.,
+19.5.2.3 [syserr.errcode.modifiers] and 19.5.3.3 [syserr.errcondition.modifiers], resp.,
 cannot be fulfilled.
 
      3. 
 
    
@@ -33114,8 +35101,8 @@ type).
 
 
  • 
 The member function message throws clauses (
-19.5.1.2 [syserr.errcat.virtuals]/10, 19.5.2.5 [syserr.errcode.observers]/8, and
-19.5.3.5 [syserr.errcondition.observers]/6) guarantee "throws nothing",
+19.5.1.2 [syserr.errcat.virtuals]/10, 19.5.2.4 [syserr.errcode.observers]/8, and
+19.5.3.4 [syserr.errcondition.observers]/6) guarantee "throws nothing",
 although
 they return a std::string by value, which might throw in out-of-memory
 conditions (see related issue 771).
@@ -33158,7 +35145,7 @@ Resolution of part A:
 
    
 
    
 
    
-Change 19.5.2.2 [syserr.errcode.overview] Class error_code overview synopsis as indicated:
+Change 19.5.2.1 [syserr.errcode.overview] Class error_code overview synopsis as indicated:
 
    
 
 
    private:
@@ -33167,7 +35154,7 @@ Change 19.5.2.2 [syserr.errcode.overview] Class error_code overview synopsis as
 
    
 
 
    
-Change 19.5.2.3 [syserr.errcode.constructors] Class error_code constructors as indicated:
+Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors as indicated:
 
    
 
 
    
@@ -33200,7 +35187,7 @@ Change 19.5.2.3 [syserr.errcode.constructors] Class error_code constructors as i
 
    
 
 
    
-Change 19.5.2.4 [syserr.errcode.modifiers] Class error_code modifiers as indicated:
+Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers as indicated:
 
    
 
 
    
@@ -33217,7 +35204,7 @@ Change 19.5.2.4 [syserr.errcode.modifiers] Class error_code modifiers as indicat
 
    
 
 
    
-Change 19.5.2.5 [syserr.errcode.observers] Class error_code observers as indicated:
+Change 19.5.2.4 [syserr.errcode.observers] Class error_code observers as indicated:
 
    
 
 
    
@@ -33233,7 +35220,7 @@ const error_category& category() const;
 
    
 
 
    
-Change 19.5.3.2 [syserr.errcondition.overview] Class error_condition overview synopsis as indicated:
+Change 19.5.3.1 [syserr.errcondition.overview] Class error_condition overview synopsis as indicated:
 
    
 
 
    private:
@@ -33242,7 +35229,7 @@ Change 19.5.3.2 [syserr.errcondition.overview] Class error_condition overview sy
 
    
 
 
    
-Change 19.5.3.3 [syserr.errcondition.constructors] Class error_condition constructors as indicated:
+Change 19.5.3.2 [syserr.errcondition.constructors] Class error_condition constructors as indicated:
 
    
 
    [
 (If the proposed resolution of issue 805 has already been applied, the
@@ -33281,7 +35268,7 @@ no effect on this resolution.)
 
    
 
 
    
-Change 19.5.3.4 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated:
+Change 19.5.3.3 [syserr.errcondition.modifiers] Class error_condition modifiers as indicated:
 
    
 
 
    
@@ -33297,7 +35284,7 @@ void assign(int val, const error_category& cat);
 
    
 
 
    
-Change 19.5.3.5 [syserr.errcondition.observers] Class error_condition observers as indicated:
+Change 19.5.3.4 [syserr.errcondition.observers] Class error_condition observers as indicated:
 
    
 
 
    
@@ -33338,7 +35325,7 @@ In 19.5.1.2 [syserr.errcat.virtuals], remove the throws clause p. 10.
 
    
 
 
    
-In 19.5.2.5 [syserr.errcode.observers], remove the throws clause p. 8.
+In 19.5.2.4 [syserr.errcode.observers], remove the throws clause p. 8.
 
    
 
 
    
@@ -33355,7 +35342,7 @@ In 19.5.2.5 [syserr.errcode.observers], remove the throws clause p. 8.
 
    
 
 
    
-In 19.5.3.5 [syserr.errcondition.observers], remove the throws clause p. 6.
+In 19.5.3.4 [syserr.errcondition.observers], remove the throws clause p. 6.
 
    
 
 
    
@@ -33489,7 +35476,7 @@ object's name virtual function shall return a pointer to the string
 
    
 
 
    
-Change 19.5.2.6 [syserr.errcode.nonmembers] Class error_code non-member functions as indicated:
+Change 19.5.2.5 [syserr.errcode.nonmembers] Class error_code non-member functions as indicated:
 
    
 
 
    
@@ -33502,7 +35489,7 @@ Change 19.5.2.6 [syserr.errcode.nonmembers] Class error_code non-member
 
    
 
 
    
-Change 19.5.3.6 [syserr.errcondition.nonmembers] Class error_condition non-member functions as indicated:
+Change 19.5.3.5 [syserr.errcondition.nonmembers] Class error_condition non-member functions as indicated:
 
    
 
 
    
@@ -33632,7 +35619,7 @@ intuitive. There are no uses of errc in the current C++ standard.
 
 
    
 
    806. unique_ptr::reset effects incorrect, too permissive
    
-
    Section: 20.8.9.2.5 [unique.ptr.single.modifiers] Status: CD1
+
    Section: 20.8.14.2.5 [unique.ptr.single.modifiers] Status: CD1
  Submitter: Peter Dimov Opened: 2008-03-13  Last modified: 2008-09-26
    
 
    View all other issues in [unique.ptr.single.modifiers].
    
 
    View all issues with CD1 status.
    
@@ -33685,7 +35672,7 @@ scenario, as it definitely doesn't when p and q are separate.
 
    Proposed resolution:
    
 
 
    
-Change 20.8.9.2.5 [unique.ptr.single.modifiers]:
+Change 20.8.14.2.5 [unique.ptr.single.modifiers]:
 
    
 
 
    
@@ -33697,7 +35684,7 @@ Change 20.8.9.2.5 [unique.ptr.single.modifiers]:
 
    
 
 
    
-Change 20.8.9.3.3 [unique.ptr.runtime.modifiers]:
+Change 20.8.14.3.3 [unique.ptr.runtime.modifiers]:
 
    
 
 
    
@@ -33720,7 +35707,6 @@ Change 20.8.9.3.3 [unique.ptr.runtime.modifiers]:
 
    807. tuple construction should not fail unless its element's construction fails
    
 
    Section: 20.5.2.1 [tuple.cnstr] Status: CD1
  Submitter: Howard Hinnant Opened: 2008-03-13  Last modified: 2008-09-26
    
-
    View other active issues in [tuple.cnstr].
    
 
    View all other issues in [tuple.cnstr].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -33748,9 +35734,8 @@ or assignment of one of the types in Types throws an exception.
 
 
    
 
    808. [forward] incorrect redundant specification
    
-
    Section: 20.3.2 [forward] Status: CD1
+
    Section: 20.3.3 [forward] Status: CD1
  Submitter: Jens Maurer Opened: 2008-03-13  Last modified: 2008-09-26
    
-
    View other active issues in [forward].
    
 
    View all other issues in [forward].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
@@ -33788,7 +35773,7 @@ is just wrong and also redundant.
 
 
    Proposed resolution:
    
 
    
-Change 20.3.2 [forward] as indicated:
+Change 20.3.3 [forward] as indicated:
 
    
 
 
    
@@ -33829,7 +35814,7 @@ In both cases, A2 is deduced as double, so 1.414 is forwarded to A<
 
 
    
 
    809. std::swap should be overloaded for array types
    
-
    Section: 25.4.3 [alg.swap] Status: CD1
+
    Section: 25.3.3 [alg.swap] Status: CD1
  Submitter: Niels Dekker Opened: 2008-02-28  Last modified: 2008-09-26
    
 
    View all other issues in [alg.swap].
    
 
    View all issues with CD1 status.
    
@@ -33896,13 +35881,13 @@ Library] Shouldn't std::swap be overloaded for C-style arrays?
 
 
    Proposed resolution:
    
 
    
-Add an extra condition to the definition of Swappable requirements [swappable] in X [utility.arg.requirements]:
+Add an extra condition to the definition of Swappable requirements [swappable] in 20.2.1 [utility.arg.requirements]:
 
    
 
    
 - T is Swappable if T is an array type whose element type is Swappable.
 
    
 
    
-Add the following to 25.4.3 [alg.swap]:
+Add the following to 25.3.3 [alg.swap]:
 
    
 
    
 
    template<class T, size_t N> void swap(T (&a)[N], T (&b)[N]);
@@ -34031,14 +36016,13 @@ In 27.7 [iostream.format], Header <iomanip> synopsis change:
 
 
    
 
    813. "empty" undefined for shared_ptr
    
-
    Section: 20.8.10.2 [util.smartptr.shared] Status: CD1
+
    Section: 20.8.15.2 [util.smartptr.shared] Status: CD1
  Submitter: Matt Austern Opened: 2008-02-26  Last modified: 2008-09-26
    
-
    View other active issues in [util.smartptr.shared].
    
 
    View all other issues in [util.smartptr.shared].
    
 
    View all issues with CD1 status.
    
 
    Discussion:
    
 
    
-Several places in 20.8.10.2 [util.smartptr.shared] refer to an "empty" shared_ptr.
+Several places in 20.8.15.2 [util.smartptr.shared] refer to an "empty" shared_ptr.
 However, that term is nowhere defined. The closest thing we have to a
 definition is that the default constructor creates an empty shared_ptr
 and that a copy of a default-constructed shared_ptr is empty. Are any
@@ -34050,7 +36034,7 @@ term or stop using it.
 One reason it's not good enough to leave this term up to the reader's
 intuition is that, in light of
 N2351
-and issue 711, most readers'
+and issue 711, most readers'
 intuitive understanding is likely to be wrong. Intuitively one might
 expect that an empty shared_ptr is one that doesn't store a pointer,
 but, whatever the definition is, that isn't it.
@@ -34160,7 +36144,7 @@ Alisdair's wording is fine.
 
 
    Proposed resolution:
    
 
    
-Append the following sentance to 20.8.10.2 [util.smartptr.shared]
+Append the following sentance to 20.8.15.2 [util.smartptr.shared]
 
    
 
    
 The shared_ptr class template stores a pointer, usually obtained
@@ -34591,7 +36575,7 @@ Pete will make the required editorial tweaks to rectify this.
 
 
    
 
    821. Minor cleanup : unique_ptr
    
-
    Section: 20.8.9.3.3 [unique.ptr.runtime.modifiers] Status: WP
+
    Section: 20.8.14.3.3 [unique.ptr.runtime.modifiers] Status: WP
  Submitter: Alisdair Meredith Opened: 2008-03-30  Last modified: 2009-03-09
    
 
    View all issues with WP status.
    
 
    Discussion:
    
@@ -34620,7 +36604,7 @@ to be a stronger match than the deleted overload. Words...
 
 
    Proposed resolution:
    
 
    
-Add to class template definition in 20.8.9.3 [unique.ptr.runtime]
+Add to class template definition in 20.8.14.3 [unique.ptr.runtime]
 
    
 
 
    
@@ -34634,7 +36618,7 @@ void swap(unique_ptr&& u);
 
    
 
 
    
-Update 20.8.9.3.3 [unique.ptr.runtime.modifiers]
+Update 20.8.14.3.3 [unique.ptr.runtime.modifiers]
 
    
 
 
    
@@ -34663,6 +36647,137 @@ Note this wording incorporates resolutions for 822. Object with explicit copy constructor no longer CopyConstructible
+
    Section: 20.2.1 [utility.arg.requirements] Status: WP
+ Submitter: James Kanze Opened: 2008-04-01  Last modified: 2009-10-26
    
+
    View other active issues in [utility.arg.requirements].
    
+
    View all other issues in [utility.arg.requirements].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+I just noticed that the following program is legal in C++03, but
+is forbidden in the current draft:
+
    
+
+
    #include <vector>
+#include <iostream>
+
+class Toto
+{
+public:
+    Toto() {}
+    explicit Toto( Toto const& ) {}
+} ;
+
+int
+main()
+{
+    std::vector< Toto > v( 10 ) ;
+    return 0 ;
+}
+
    
+
+
    
+Is this change intentional?  (And if so, what is the
+justification?  I wouldn't call such code good, but I don't see
+any reason to break it unless we get something else in return.)
+
    
+
+
    [
+San Francisco:
+]
    
+
+
+
    
+The subgroup that looked at this felt this was a good change, but it may
+already be handled by incoming concepts (we're not sure).
+
    
+
+
    [
+Post Summit:
+]
    
+
+
+
    
+
    
+Alisdair: Proposed resolution kinda funky as these tables no longer
+exist. Move from direct init to copy init. Clarify with Doug, recommends
+NAD.
+
    
+
    
+Walter: Suggest NAD via introduction of concepts.
+
    
+
    
+Recommend close as NAD.
+
    
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Need to look at again without concepts.
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+
    
+Move to Ready with original proposed resolution.
+
    
+
    [Howard:  Original proposed resolution restored.]
    
+
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+In 20.2.1 [utility.arg.requirements] change Table 33: MoveConstructible requirements [moveconstructible]:
+
    
+
+
    
+
+
+
+
+
+
+
+
+
+
+
    expressionpost-condition
    T t(rv) = rvt is equivalent to the value of rv before the construction
    ...
    
+
    
+
+
    
+In 20.2.1 [utility.arg.requirements] change Table 34: CopyConstructible requirements [copyconstructible]:
+
    
+
+
    
+
+
+
+
+
+
+
+
+
+
+
    expressionpost-condition
    T t(u) = uthe value of u is unchanged and is equivalent to t
    ...
    
+
    
+
+
+
+
+
 
    
 
    824. rvalue ref issue with basic_string inserter
    
 
    Section: 21.4.8.9 [string.io] Status: CD1
@@ -34820,9 +36935,201 @@ creates a new copy each time it is called.
 
 
 
+
    
+
    838. 
+   can an end-of-stream iterator become a non-end-of-stream one?
+ 
    
+
    Section: 24.6.1 [istream.iterator] Status: WP
+ Submitter: Martin Sebor Opened: 2008-05-17  Last modified: 2009-10-26
    
+
    View all other issues in [istream.iterator].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+   
    
+
+From message c++std-lib-20003...
+
+   
    
+   
    
+
+The description of istream_iterator in
+24.6.1 [istream.iterator], p1 specifies that objects of the
+class become the end-of-stream (EOS) iterators under the
+following condition (see also issue 788 another problem
+with this paragraph):
+
+   
    
+   
    
+
+If the end of stream is reached (operator void*() on the
+stream returns false), the iterator becomes equal to
+the end-of-stream iterator value.
+
+   
    
+   
    
+
+One possible implementation approach that has been used in practice is
+for the iterator to set its in_stream pointer to 0 when
+it reaches the end of the stream, just like the default ctor does on
+initialization. The problem with this approach is that
+the Effects clause for operator++() says the
+iterator unconditionally extracts the next value from the stream by
+evaluating *in_stream >> value, without checking
+for (in_stream == 0).
+
+   
    
+   
    
+
+Conformance to the requirement outlined in the Effects clause
+can easily be verified in programs by setting eofbit
+or failbit in exceptions() of the associated
+stream and attempting to iterate past the end of the stream: each
+past-the-end access should trigger an exception. This suggests that
+some other, more elaborate technique might be intended.
+
+   
    
+   
    
+
+Another approach, one that allows operator++() to attempt
+to extract the value even for EOS iterators (just as long
+as in_stream is non-0) is for the iterator to maintain a
+flag indicating whether it has reached the end of the stream. This
+technique would satisfy the presumed requirement implied by
+the Effects clause mentioned above, but it isn't supported by
+the exposition-only members of the class (no such flag is shown). This
+approach is also found in existing practice.
+
+   
    
+   
    
+
+The inconsistency between existing implementations raises the question
+of whether the intent of the specification is that a non-EOS iterator
+that has reached the EOS become a non-EOS one again after the
+stream's eofbit flag has been cleared? That is, are the
+assertions in the program below expected to pass?
+
+   
    
+   
    
+     
       sstream strm ("1 ");
+   istream_iterator eos;
+   istream_iterator it (strm);
+   int i;
+   i = *it++
+   assert (it == eos);
+   strm.clear ();
+   strm << "2 3 ";
+   assert (it != eos);
+   i = *++it;
+   assert (3 == i);
+     
    
+   
    
+   
    
+
+Or is it intended that once an iterator becomes EOS it stays EOS until
+the end of its lifetime?
+
+   
    
+ 
+ 
    [
+San Francisco:
+]
    
+
+
+
    
+
    
+We like the direction of the proposed resolution. We're not sure about
+the wording, and we need more time to reflect on it,
+
    
+
    
+Move to Open. Detlef to rewrite the proposed resolution in such a way
+that no reference is made to exposition only members of
+istream_iterator.
+
    
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+ 
    Proposed resolution:
    
+   
    
+
+The discussion of this issue on the reflector suggests that the intent
+of the standard is for an istreambuf_iterator that has
+reached the EOS to remain in the EOS state until the end of its
+lifetime. Implementations that permit EOS iterators to return to a
+non-EOS state may only do so as an extension, and only as a result of
+calling istream_iterator member functions on EOS
+iterators whose behavior is in this case undefined.
+
+   
    
+   
    
+
+To this end we propose to change 24.6.1 [istream.iterator], p1,
+as follows:
+
+   
    
+   
    
+
+The result of operator-> on an end-of-stream
+is not defined. For any other iterator value a const T*
+is returned. Invoking operator++() on
+an end-of-stream iterator is undefined. It is impossible
+to store things into istream iterators...
+
+   
    
+   
    
+
+Add pre/postconditions to the member function descriptions of istream_iterator like so:
+
+   
    
+   
    
+
+
    istream_iterator();
    
+
+Effects: Constructs the end-of-stream iterator.
    
+Postcondition: in_stream == 0.
+
+
    istream_iterator(istream_type &s);
    
+
+Effects: Initializes in_stream with &s. value
+may be initialized during construction or the first time it is
+referenced.
    
+Postcondition: in_stream == &s.
+
+
    istream_iterator(const istream_iterator &x);
    
+
+Effects: Constructs a copy of x.
    
+Postcondition: in_stream == x.in_stream.
+
+
    istream_iterator& operator++();
    
+
+Requires: in_stream != 0.
    
+Effects: *in_stream >> value.
+
+
    istream_iterator& operator++(int);
    
+
+Requires: in_stream != 0.
    
+Effects:
+   
    istream_iterator tmp (*this);
+*in_stream >> value;
+return tmp;
+     
    
+     
    
+   
    
+ 
+
+
+
 
    
 
    842. ConstructibleAsElement and bit containers
    
-
    Section: 23.2 [container.requirements], 23.3.7 [vector.bool], 20.3.6 [template.bitset] Status: CD1
+
    Section: 23.2 [container.requirements], 23.3.7 [vector.bool], 20.3.7 [template.bitset] Status: CD1
  Submitter: Howard Hinnant Opened: 2008-06-03  Last modified: 2008-09-26
    
 
    View other active issues in [container.requirements].
    
 
    View all other issues in [container.requirements].
    
@@ -34847,7 +37154,7 @@ with a scoped allocator of type A (i.e., an allocator for which
 
 
    
 However vector<bool, A> (23.3.7 [vector.bool]) and bitset<N> 
-(20.3.6 [template.bitset]) store bits, not bools, and bitset<N>
+(20.3.7 [template.bitset]) store bits, not bools, and bitset<N>
 does not even have an allocator.  But these containers are governed by this clause.  Clearly this
 is not implementable.
 
    
@@ -34883,7 +37190,7 @@ and construct_element (23.2 [container.requirements]) is not used to co
 
    
 
 
    
-Move 20.3.6 [template.bitset] to clause 20.
+Move 20.3.7 [template.bitset] to clause 20.
 
    
 
 
@@ -35243,9 +37550,132 @@ Construction is not atomic.
 
 
 
+
    
+
    847. string exception safety guarantees
    
+
    Section: 21.4.1 [string.require] Status: WP
+ Submitter: Hervé Brönnimann Opened: 2008-06-05  Last modified: 2009-10-26
    
+
    View all other issues in [string.require].
    
+
    View all issues with WP status.
    
+
    Discussion:
    
+
    
+In March, on comp.lang.c++.moderated, I asked what were the
+string exception safety guarantees are, because I cannot see
+*any* in the working paper, and any implementation I know offers
+the strong exception safety guarantee (string unchanged if a
+member throws exception). The closest the current draft comes to
+offering any guarantees is 21.4 [basic.string], para 3:
+
    
+
+
    
+The class template basic_string conforms to the requirements
+for a Sequence Container (23.1.1), for a Reversible Container (23.1),
+and for an Allocator-aware container (91). The iterators supported by
+basic_string are random access iterators (24.1.5).
+
    
+
+
    
+However, the chapter 23 only says, on the topic of exceptions:  23.2 [container.requirements],
+para 10:
+
    
+
+
    
+
    
+Unless otherwise specified (see 23.2.2.3 and 23.2.6.4) all container types defined in this clause meet the following 
+additional requirements:
+
    
+
+
      
+
    • if an exception is thrown by...
      • 
+
    
+
    
+
+
    
+I take it  as saying that this paragraph has *no* implication on
+std::basic_string, as basic_string isn't defined in Clause 23 and
+this paragraph does not define a *requirement* of Sequence
+nor Reversible Container, just of the models defined in Clause 23.
+In addition, LWG Issue 718 proposes to remove 23.2 [container.requirements], para 3.
+
    
+
+
    
+Finally, the fact that no operation on Traits should throw
+exceptions has no bearing, except to suggest (since the only
+other throws should be allocation, out_of_range, or length_error)
+that the strong exception guarantee can be achieved.
+
    
+
+
    
+The reaction in that group by Niels Dekker, Martin Sebor, and
+Bo Persson, was all that this would be worth an LWG issue.
+
    
+
+
    
+A related issue is that erase() does not throw.  This should be
+stated somewhere (and again, I don't think that the 23.2 [container.requirements], para 1
+applies here).
+
    
+
+
    [
+San Francisco:
+]
    
+
+
+
    
+Implementors will study this to confirm that it is actually possible.
+
    
+
+
    [
+Daniel adds 2009-02-14:
+]
    
+
+
+
    
+The proposed resolution of paper
+N2815
+interacts with this issue (the paper does not refer to this issue).
+
    
+
+
    [
+2009-07 Frankfurt:
+]
    
+
+
+
    
+Move to Ready.
+
    
+
+
+
+
    Proposed resolution:
    
+
    
+Add a blanket statement in 21.4.1 [string.require]:
+
    
+
+
    
+
    
+- if any member function or operator of basic_string<charT, traits, Allocator>
+throws, that function or operator has no effect.
+
    
+
    
+- no erase() or pop_back() function throws.
+
    
+
    
+
+
    
+As far as I can tell, this is achieved by any implementation.  If I made a
+mistake and it is not possible to offer this guarantee, then
+either state all the functions for which this is possible
+(certainly at least operator+=, append, assign, and insert),
+or add paragraphs to Effects clauses wherever appropriate.
+
    
+
+
+
+
+
 
    
 
    848. missing std::hash specializations for std::bitset/std::vector<bool>
    
-
    Section: 20.7.17 [unord.hash] Status: CD1
+
    Section: 20.7.16 [unord.hash] Status: CD1
  Submitter: Thorsten Ottosen Opened: 2008-06-05  Last modified: 2008-09-26
    
 
    View other active issues in [unord.hash].
    
 
    View all other issues in [unord.hash].
    
@@ -35271,7 +37701,7 @@ template<size_t N> struct hash<std::bitset<N>>;
 
    
 
 
    
-Modify the last sentence of 20.7.17 [unord.hash]/1 to end with:
+Modify the last sentence of 20.7.16 [unord.hash]/1 to end with:
 
    
 
 
    
@@ -35382,7 +37812,7 @@ Change the synopsis in 23.5.1 [unord.map], 23.5.2 [unord.multimap], and 23.5.4 [
 
 
    
 
    853. to_string needs updating with zero and one
    
-
    Section: 20.3.6 [template.bitset] Status: WP
+
    Section: 20.3.7 [template.bitset] Status: WP
  Submitter: Howard Hinnant Opened: 2008-06-18  Last modified: 2009-07-18
    
 
    View other active issues in [template.bitset].
    
 
    View all other issues in [template.bitset].
    
@@ -35435,7 +37865,7 @@ Recommend Tentatively Ready.
 
    Proposed resolution:
    
 
      
 
    1. 
-
      replace in 20.3.6 [template.bitset]/1 (class bitset)
+
      replace in 20.3.7 [template.bitset]/1 (class bitset)
 
      
 
      template <class charT, class traits>
   basic_string<charT, traits, allocator<charT> >
@@ -35449,7 +37879,7 @@ basic_string<char, char_traits<char>, allocator<char> >
 
      2. 
 
    2. 
 
      
-replace in 20.3.6.2 [bitset.members]/37
+replace in 20.3.7.2 [bitset.members]/37
 
      
 
      template <class charT, class traits>
   basic_string<charT, traits, allocator<charT> >
@@ -35462,7 +37892,7 @@ replace in 20.3.6.2 [bitset.members]/37
 
      3. 
 
    3. 
 
      
-replace in 20.3.6.2 [bitset.members]/38
+replace in 20.3.7.2 [bitset.members]/38
 
      
 
 
      template <class charT>
@@ -35477,7 +37907,7 @@ replace in 20.3.6.2 [bitset.members]/38
 
 
    4. 
 
      
-replace in 20.3.6.2 [bitset.members]/39
+replace in 20.3.7.2 [bitset.members]/39
 
      
 
 
      basic_string<char, char_traits<char>, allocator<char> >
@@ -35500,7 +37930,6 @@ replace in 20.3.6.2 [bitset.members]/39
 
      856. Removal of aligned_union
      
 
      Section: 20.6.7 [meta.trans.other] Status: CD1
  Submitter: Jens Maurer Opened: 2008-06-12  Last modified: 2008-09-26
      
-
      View other active issues in [meta.trans.other].
      
 
      View all other issues in [meta.trans.other].
      
 
      View all issues with CD1 status.
      
 
      Discussion:
      
@@ -35534,9 +37963,389 @@ struct aligned_union;
 
 
 
+
      
+
      857. condition_variable::time_wait return bool error prone
      
+
      Section: 30.5.1 [thread.condition.condvar] Status: WP
+ Submitter: Beman Dawes Opened: 2008-06-13  Last modified: 2009-10-26
      
+
      View other active issues in [thread.condition.condvar].
      
+
      View all other issues in [thread.condition.condvar].
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
      
+The meaning of the bool returned by condition_variable::timed_wait is so
+obscure that even the class' designer can't deduce it correctly. Several
+people have independently stumbled on this issue.
+
      
+
      
+It might be simpler to change the return type to a scoped enum:
+
      
+
      enum class timeout { not_reached, reached };
+
      
+
+
      
+That's the same cost as returning a bool, but not subject to mistakes. Your example below would be:
+
      
+
+
      if (cv.wait_until(lk, time_limit) == timeout::reached )
+  throw time_out();
+
      
+
+
      [
+Beman to supply exact wording.
+]
      
+
+
+
      [
+San Francisco:
+]
      
+
+
+
      
+
      
+There is concern that the enumeration names are just as confusing, if
+not more so, as the bool. You might have awoken because of a signal or a
+spurious wakeup, for example.
+
      
+
      
+Group feels that this is a defect that needs fixing.
+
      
+
      
+Group prefers returning an enum over a void return.
+
      
+
      
+Howard to provide wording.
+
      
+
      
+
+
      [
+2009-06-14 Beman provided wording.
+]
      
+
+
+
      [
+2009-07 Frankfurt:
+]
      
+
+
+
      
+Move to Ready.
+
      
+
+
+
+
      Proposed resolution:
      
+
      
+Change Condition variables 30.5 [thread.condition], Header
+condition_variable synopsis, as indicated:
+
      
+
+
      namespace std {
+  class condition_variable;
+  class condition_variable_any;
+
+  enum class cv_status { no_timeout, timeout };
+}
+
      
+
+
      
+Change Class condition_variable 30.5.1 [thread.condition.condvar] as indicated:
+
      
+
+
      class condition_variable { 
+public:
+  ...
+  template <class Clock, class Duration>
+    bool cv_status wait_until(unique_lock<mutex>& lock,
+                    const chrono::time_point<Clock, Duration>& abs_time);
+  template <class Clock, class Duration, class Predicate>
+    bool wait_until(unique_lock<mutex>& lock,
+                    const chrono::time_point<Clock, Duration>& abs_time,
+                    Predicate pred);
+
+  template <class Rep, class Period>
+    bool cv_status wait_for(unique_lock<mutex>& lock,
+                  const chrono::duration<Rep, Period>& rel_time);
+  template <class Rep, class Period, class Predicate>
+    bool wait_for(unique_lock<mutex>& lock,
+                  const chrono::duration<Rep, Period>& rel_time,
+                  Predicate pred);
+  ...
+};
+
+...
+
+template <class Clock, class Duration>
+  bool cv_status wait_until(unique_lock<mutex>& lock,
+                  const chrono::time_point<Clock, Duration>& abs_time);
+
      
+
      
+
      
+-15- Precondition: lock is locked by the calling thread, and either
+
      
+
        
+
      • 
+no other thread is waiting on this condition_variable object or
+
        • 
+
      • 
+lock.mutex() returns the same value for each of the lock
+arguments supplied by all concurrently waiting threads (via wait,
+wait_for or wait_until.).
+
        • 
+
      
+
+
      
+-16- Effects:
+
      
+
+
        
+
      • 
+Atomically calls lock.unlock() and blocks on *this.
+
        • 
+
      • 
+When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
+
        • 
+
      • 
+The function will unblock when signaled by a call to notify_one(),
+a call to notify_all(), by 
+the current time exceeding abs_time if Clock::now() >= abs_time,
+or spuriously.
+
        • 
+
      • 
+If the function exits via an exception, lock.unlock() shall be called prior
+to exiting the function scope.
+
        • 
+
      
+
+
      
+-17- Postcondition: lock is locked by the calling thread.
+
      
+
+
      
+-18- Returns: Clock::now() < abs_time
+cv_status::timeout if the function unblocked because abs_time
+was reached, otherwise cv_status::no_timeout.
+
      
+
+
      
+-19- Throws: std::system_error when the effects or postcondition
+cannot be achieved.
+
      
+
+
      
+-20- Error conditions:
+
      
+
+
        
+
      • 
+operation_not_permitted — if the thread does not own the lock.
+
        • 
+
      • 
+equivalent error condition from lock.lock() or lock.unlock().
+
        • 
+
      
+
      
+
+
      template <class Rep, class Period>
+  bool cv_status wait_for(unique_lock<mutex>& lock,
+                const chrono::duration<Rep, Period>& rel_time);
+
+
      
+
      
+
      
+-21- Effects Returns:
+
      
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+
      
+
      
+-22- Returns: false if the call is returning because the time
+duration specified by rel_time has elapsed, 
+otherwise true.
+
      
+
+
      [
+This part of the wording may conflict with 859 in detail, but does
+not do so in spirit.  If both issues are accepted, there is a logical merge.
+]
      
+
+
      
+
+
      template <class Clock, class Duration, class Predicate> 
+  bool wait_until(unique_lock<mutex>& lock, 
+                  const chrono::time_point<Clock, Duration>& abs_time, 
+                  Predicate pred);
+
      
+
+
      
+
      
+-23- Effects:
+
      
+
      while (!pred()) 
+  if (!wait_until(lock, abs_time) == cv_status::timeout) 
+    return pred(); 
+return true;
+
      
+
+
      
+-24- Returns: pred().
+
      
+
+
      
+-25- [Note:
+The returned value indicates whether the predicate evaluates to
+true regardless of whether the timeout was triggered.
+— end note].
+
      
+
      
+
      
+
+
      
+Change Class condition_variable_any 30.5.2 [thread.condition.condvarany] as indicated:
+
      
+
+
      class condition_variable_any {
+public:
+  ...
+  template <class Lock, class Clock, class Duration>
+    bool cv_status wait_until(Lock& lock,
+                    const chrono::time_point<Clock, Duration>& abs_time);
+  template <class Lock, class Clock, class Duration, class Predicate>
+    bool wait_until(Lock& lock,
+                    const chrono::time_point<Clock, Duration>& abs_time,
+                    Predicate pred);
+
+  template <class Lock, class Rep, class Period>
+    bool cv_status wait_for(Lock& lock,
+                  const chrono::duration<Rep, Period>& rel_time);
+  template <class Lock, class Rep, class Period, class Predicate>
+    bool wait_for(Lock& lock,
+                  const chrono::duration<Rep, Period>& rel_time,
+                  Predicate pred);
+  ...
+};
+
+...
+
+template <class Lock, class Clock, class Duration>
+  bool cv_status wait_until(Lock& lock,
+                  const chrono::time_point<Clock, Duration>& abs_time);
+
      
+
+
      
+
+
      
+-13- Effects:
+
      
+
+
        
+
      • 
+Atomically calls lock.unlock() and blocks on *this.
+
        • 
+
      • 
+When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
+
        • 
+
      • 
+The function will unblock when signaled by a call to notify_one(),
+a call to notify_all(), by 
+the current time exceeding abs_time if Clock::now() >= abs_time,
+or spuriously.
+
        • 
+
      • 
+If the function exits via an exception, lock.unlock() shall be called prior
+to exiting the function scope.
+
        • 
+
      
+
+
      
+-14- Postcondition: lock is locked by the calling thread.
+
      
+
+
      
+-15- Returns: Clock::now() < abs_time
+cv_status::timeout if the function unblocked because abs_time
+was reached, otherwise cv_status::no_timeout.
+
      
+
+
      
+-16- Throws: std::system_error when the effects or postcondition
+cannot be achieved.
+
      
+
+
      
+-17- Error conditions:
+
      
+
+
        
+
      • 
+equivalent error condition from lock.lock() or lock.unlock().
+
        • 
+
      
+
      
+
+
      template <class Lock, class Rep, class Period>
+  bool cv_status wait_for(Lock& lock,
+                const chrono::duration<Rep, Period>& rel_time);
+
+
      
+
+
      
+
      
+-18- Effects Returns:
+
      
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+
      
+
+
      
+-19- Returns: false if the call is returning because the time
+duration specified by rel_time has elapsed, 
+otherwise true.
+
      
+
+
      [
+This part of the wording may conflict with 859 in detail, but does
+not do so in spirit.  If both issues are accepted, there is a logical merge.
+]
      
+
+
+
      
+
+
      template <class Lock, class Clock, class Duration, class Predicate> 
+  bool wait_until(Lock& lock, 
+                  const chrono::time_point<Clock, Duration>& rel_time abs_time, 
+                  Predicate pred);
+
      
+
+
      
+
      
+-20- Effects:
+
      
+
      while (!pred()) 
+  if (!wait_until(lock, abs_time) == cv_status::timeout) 
+    return pred(); 
+return true;
+
      
+
+
      
+-21- Returns: pred().
+
      
+
+
      
+-22- [Note:
+The returned value indicates whether the predicate evaluates to
+true regardless of whether the timeout was triggered.
+— end note].
+
      
+
      
+
+
      
+
+
+
+
+
+
 
      
 
      858. Wording for Minimal Support for Garbage Collection
      
-
      Section: 20.8.10.7 [util.dynamic.safety] Status: CD1
+
      Section: 20.8.15.6 [util.dynamic.safety] Status: CD1
  Submitter: Pete Becker  Opened: 2008-06-21  Last modified: 2008-09-26
      
 
      View all other issues in [util.dynamic.safety].
      
 
      View all issues with CD1 status.
      
@@ -35587,7 +38396,7 @@ to clarify the intent.
 
 
      Proposed resolution:
      
 
      
-In 20.8.10.7 [util.dynamic.safety]
+In 20.8.15.6 [util.dynamic.safety]
 (N2670,
 Minimal Support for Garbage Collection)
 
      
@@ -35656,22 +38465,475 @@ note]
 
 
 
+
      
+
      859. Monotonic Clock is Conditionally Supported?
      
+
      Section: 30.5 [thread.condition] Status: WP
+ Submitter: Pete Becker Opened: 2008-06-23  Last modified: 2009-10-26
      
+
      View other active issues in [thread.condition].
      
+
      View all other issues in [thread.condition].
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
+
      Related to 958, 959.
      
+
+
      
+N2661
+says that there is a class named monotonic_clock. It also says that this
+name may be a synonym for system_clock, and that it's conditionally
+supported. So the actual requirement is that it can be monotonic or not,
+and you can tell by looking at is_monotonic, or it might not exist at
+all (since it's conditionally supported). Okay, maybe too much
+flexibility, but so be it.
+
      
+
      
+A problem comes up in the threading specification, where several
+variants of wait_for explicitly use monotonic_clock::now(). What is the
+meaning of an effects clause that says
+
      
+
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+
      
+
+
      
+when monotonic_clock is not required to exist?
+
      
+
+
      [
+San Francisco:
+]
      
+
+
+
      
+
      
+Nick: maybe instead of saying that chrono::monotonic_clock is
+conditionally supported, we could say that it's always there, but not
+necessarily supported..
+
      
+
      
+Beman: I'd prefer a typedef that identifies the best clock to use for
+wait_for locks.
+
      
+
      
+Tom: combine the two concepts; create a duration clock type, but keep
+the is_monotonic test.
+
      
+
      
+Howard: if we create a duration_clock type, is it a typedef or an
+entirely true type?
+
      
+
      
+There was broad preference for a typedef.
+
      
+
      
+Move to Open. Howard to provide wording to add a typedef for
+duration_clock and to replace all uses of monotonic_clock in function
+calls and signatures with duration_clock.
+
      
+
      
+
+
      [
+Howard notes post-San Francisco:
+]
      
+
+
+
      
+
      
+After further thought I do not believe that creating a duration_clock typedef
+is the best way to proceed.  An implementation may not need to use a
+time_point to implement the wait_for functions.
+
      
+
+
      
+For example, on POSIX systems sleep_for can be implemented in terms of
+nanosleep which takes only a duration in terms of nanoseconds.  The current
+working paper does not describe sleep_for in terms of sleep_until.
+And paragraph 2 of 30.2.4 [thread.req.timing] has the words strongly encouraging
+implementations to use monotonic clocks for sleep_for:
+
      
+
+
      
+2 The member functions whose names end in _for take an argument that
+specifies a relative time. Implementations should use a monotonic clock to
+measure time for these functions.
+
      
+
+
      
+I believe the approach taken in describing the effects of sleep_for
+and try_lock_for is also appropriate for wait_for.  I.e. these
+are not described in terms of their _until variants.
+
      
+
+
      
+
+
      [
+2009-07 Frankfurt:
+]
      
+
+
+
      
+
      
+Beman will send some suggested wording changes to Howard.
+
      
+
      
+Move to Ready.
+
      
+
      
+
+
      [
+2009-07-21 Beman added the requested wording changes to 962.
+]
      
+
+
+
+
+
      Proposed resolution:
      
+
      
+Change 30.5.1 [thread.condition.condvar], p21-22:
+
      
+
+
      
+
      template <class Rep, class Period> 
+  bool wait_for(unique_lock<mutex>& lock, 
+                const chrono::duration<Rep, Period>& rel_time);
+
      
+
      
+
      
+Precondition: lock is locked by the calling thread, and either
+
      
+
        
+
      • no other thread is waiting on this condition_variable object or
        • 
+
      • lock.mutex() returns the same value for each of the lock
+arguments supplied by all concurrently waiting threads (via wait,
+wait_for or wait_until).
        • 
+
      
+
      
+21 Effects:
+
      
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+
      
+
        
+
      • 
+Atomically calls lock.unlock() and blocks on *this.
+
        • 
+
+
      • 
+When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
+
        • 
+
+
      • 
+The function will unblock when signaled by a call to notify_one(), a call
+to notify_all(), by 
+the elapsed time rel_time passing (30.2.4 [thread.req.timing]),
+or spuriously.
+
        • 
+
+
      • 
+If the function exits via an exception, lock.unlock() shall be called 
+prior to exiting the function scope.
+
        • 
+
      
+
+
      
+Postcondition: lock is locked by the calling thread.
+
      
+
+
+
      
+22 Returns: false if the call is returning because the time
+duration specified by rel_time has elapsed, otherwise true.
+
      
+
+
      [
+This part of the wording may conflict with 857 in detail, but does
+not do so in spirit.  If both issues are accepted, there is a logical merge.
+]
      
+
+
+
      
+Throws: std::system_error when the effects or postcondition cannot be achieved.
+
      
+
+
      
+Error conditions:
+
      
+
+
        
+
      • 
+operation_not_permitted -- if the thread does not own the lock.
+
        • 
+
      • 
+equivalent error condition from lock.lock() or lock.unlock().
+
        • 
+
      
+
+
      
+
      
+
+
      
+Change 30.5.1 [thread.condition.condvar], p26-p29:
+
      
+
+
      
+
      template <class Rep, class Period, class Predicate> 
+  bool wait_for(unique_lock<mutex>& lock, 
+                const chrono::duration<Rep, Period>& rel_time, 
+                Predicate pred);
+
      
+
      
+
      
+Precondition: lock is locked by the calling thread, and either
+
      
+
        
+
      • no other thread is waiting on this condition_variable object or
        • 
+
      • lock.mutex() returns the same value for each of the lock
+arguments supplied by all concurrently waiting threads (via wait,
+wait_for or wait_until).
        • 
+
      
+
      
+26 Effects:
+
      
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))
+
      
+
        
+
      • 
+Executes a loop:  Within the loop the function first evaluates pred()
+and exits the loop if the result of pred() is true.
+
        • 
+
      • 
+Atomically calls lock.unlock()
+and blocks on *this.
+
        • 
+
      • 
+When unblocked, calls lock.lock() (possibly blocking on the lock).
+
        • 
+
      • 
+The function will unblock when signaled by a call to notify_one(), a
+call to notify_all(), by the elapsed time rel_time passing (30.1.4
+[thread.req.timing]), or spuriously.
+
        • 
+
      • 
+If the function exits via an exception, lock.unlock() shall be called
+prior to exiting the function scope.
+
        • 
+
      • 
+The loop terminates when pred() returns true or when the time
+duration specified by rel_time has elapsed.
+
        • 
+
      
+
      
+
+
      
+27 [Note: There is no blocking if pred() is initially true,
+even if the timeout has already expired. -- end note]
+
      
+
+
      
+Postcondition: lock is locked by the calling thread.
+
      
+
+
      
+28 Returns: pred()
+
      
+
+
      
+29 [Note: The returned value indicates whether the predicate evaluates to
+true regardless of whether the timeout was triggered. -- end note]
+
      
+
+
      
+Throws: std::system_error when the effects or postcondition cannot be achieved.
+
      
+
+
      
+Error conditions:
+
      
+
+
        
+
      • 
+operation_not_permitted -- if the thread does not own the lock.
+
        • 
+
      • 
+equivalent error condition from lock.lock() or lock.unlock().
+
        • 
+
      
+
+
      
+
      
+
+
      
+Change 30.5.2 [thread.condition.condvarany], p18-19:
+
      
+
+
      
+
      template <class Lock, class Rep, class Period> 
+  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
+
      
+
      
+
      
+18 Effects:
+
      
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time)
+
      
+
+
        
+
      • 
+Atomically calls lock.unlock() and blocks on *this.
+
        • 
+
+
      • 
+When unblocked, calls lock.lock() (possibly blocking on the lock) and returns.
+
        • 
+
+
      • 
+The function will unblock when signaled by a call to notify_one(), a call to
+notify_all(), by
+the elapsed time rel_time passing (30.2.4 [thread.req.timing]),
+or spuriously.
+
        • 
+
+
      • 
+If the function exits via an exception, lock.unlock() shall be called
+prior to exiting the function scope.
+
        • 
+
      
+
+
      
+Postcondition: lock is locked by the calling thread.
+
      
+
+
      
+19 Returns: false if the call is returning because the time duration
+specified by rel_time has elapsed, otherwise true.
+
      
+
+
      
+Throws: std::system_error when the returned value, effects,
+or postcondition cannot be achieved.
+
      
+
+
      
+Error conditions:
+
      
+
+
        
+
      • 
+equivalent error condition from lock.lock() or lock.unlock().
+
        • 
+
      
+
      
+
      
+
+
      
+Change 30.5.2 [thread.condition.condvarany], p23-p26:
+
      
+
+
      
+
      template <class Lock, class Rep, class Period, class Predicate> 
+  bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
+
      
+
      
+
      
+Precondition: lock is locked by the calling thread, and either
+
      
+
        
+
      • no other thread is waiting on this condition_variable object or
        • 
+
      • lock.mutex() returns the same value for each of the lock
+arguments supplied by all concurrently waiting threads (via wait,
+wait_for or wait_until).
        • 
+
      
+
      
+23 Effects:
+
      
+
      wait_until(lock, chrono::monotonic_clock::now() + rel_time, std::move(pred))
+
      
+
        
+
      • 
+Executes a loop:  Within the loop the function first evaluates pred()
+and exits the loop if the result of pred() is true.
+
        • 
+
      • 
+Atomically calls lock.unlock()
+and blocks on *this.
+
        • 
+
      • 
+When unblocked, calls lock.lock() (possibly blocking on the lock).
+
        • 
+
      • 
+The function will unblock when signaled by a call to notify_one(), a
+call to notify_all(), by the elapsed time rel_time passing (30.1.4
+[thread.req.timing]), or spuriously.
+
        • 
+
      • 
+If the function exits via an exception, lock.unlock() shall be called
+prior to exiting the function scope.
+
        • 
+
      • 
+The loop terminates when pred() returns true or when the time
+duration specified by rel_time has elapsed.
+
        • 
+
      
+
      
+
+
      
+24 [Note: There is no blocking if pred() is initially true,
+even if the timeout has already expired. -- end note]
+
      
+
+
      
+Postcondition: lock is locked by the calling thread.
+
      
+
+
      
+25 Returns: pred()
+
      
+
+
      
+26 [Note: The returned value indicates whether the predicate evaluates to
+true regardless of whether the timeout was triggered. -- end note]
+
      
+
+
      
+Throws: std::system_error when the effects or postcondition cannot be achieved.
+
      
+
+
      
+Error conditions:
+
      
+
+
        
+
      • 
+operation_not_permitted -- if the thread does not own the lock.
+
        • 
+
      • 
+equivalent error condition from lock.lock() or lock.unlock().
+
        • 
+
      
+
+
      
+
      
+
+
+
+
+
+
+
 
      
 
      866. Qualification of placement new-expressions
      
-
      Section: 20.8.8 [specialized.algorithms], 20.8.10.2.6 [util.smartptr.shared.create] Status: WP
+
      Section: 20.8.13 [specialized.algorithms], 20.8.15.2.6 [util.smartptr.shared.create] Status: WP
  Submitter: Alberto Ganesh Barbati Opened: 2008-07-14  Last modified: 2009-03-09
      
 
      View all other issues in [specialized.algorithms].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
 
      
 LWG issue 402 replaced "new" with "::new" in the placement
-new-expression in 20.8.4.1 [allocator.members]. I believe the rationale
+new-expression in 20.8.8.1 [allocator.members]. I believe the rationale
 given in 402 applies also to the following other contexts:
 
      
 
        
 
      • 
 
        
-in 20.8.8 [specialized.algorithms], all four algorithms unitialized_copy,
+in 20.8.13 [specialized.algorithms], all four algorithms unitialized_copy,
 unitialized_copy_n, unitialized_fill and unitialized_fill_n use
 the unqualified placement new-expression in some variation of the form:
 
        
@@ -35680,7 +38942,7 @@ the unqualified placement new-expression in some variation of the form:
 
        • 
 
      • 
 
        
-in 20.8.10.2.6 [util.smartptr.shared.create] there is a reference to the unqualified placement new-expression:
+in 20.8.15.2.6 [util.smartptr.shared.create] there is a reference to the unqualified placement new-expression:
 
        
 
        new  (pv)  T(std::forward<Args>(args)...),
 
        
@@ -35729,16 +38991,16 @@ Replace "new" with "::new" in:
 
        
 
          
 
        • 
-20.8.8.2 [uninitialized.copy], paragraphs 1 and 3
+20.8.13.2 [uninitialized.copy], paragraphs 1 and 3
 
          • 
 
        • 
-20.8.8.3 [uninitialized.fill]  paragraph 1
+20.8.13.3 [uninitialized.fill]  paragraph 1
 
          • 
 
        • 
-20.8.8.4 [uninitialized.fill.n] paragraph 1
+20.8.13.4 [uninitialized.fill.n] paragraph 1
 
          • 
 
        • 
-20.8.10.2.6 [util.smartptr.shared.create] once in paragraph 1 and twice in paragraph 2.
+20.8.15.2.6 [util.smartptr.shared.create] once in paragraph 1 and twice in paragraph 2.
 
          • 
 
        
 
@@ -35827,6 +39089,179 @@ If the bucket is empty, then b.begin(n) == b.end(n).
 
 
 
+
        
+
        876. basic_string access operations should give stronger guarantees
        
+
        Section: 21.4 [basic.string] Status: WP
+ Submitter: Daniel Krügler Opened: 2008-08-22  Last modified: 2009-10-26
        
+
        View all other issues in [basic.string].
        
+
        View all issues with WP status.
        
+
        Discussion:
        
+
        
+During the Sophia Antipolis meeting it was decided to split-off some
+parts of the
+n2647
+("Concurrency modifications for basic_string")
+proposal into a separate issue, because these weren't actually
+concurrency-related. The here proposed changes refer to the recent
+update document
+n2668
+and attempt to take advantage of the
+stricter structural requirements.
+
        
+
        
+Indeed there exists some leeway for more guarantees that would be
+very useful for programmers, especially if interaction with transactionary
+or exception-unaware C API code is important. This would also allow
+compilers to take advantage of more performance optimizations, because
+more functions can have throw() specifications. This proposal uses the
+form of "Throws: Nothing" clauses to reach the same effect, because
+there already exists a different issue in progress to clean-up the current
+existing "schizophrenia" of the standard in this regard.
+
        
+
        
+Due to earlier support for copy-on-write, we find the following
+unnecessary limitations for C++0x:
+
        
+
+
          
+
        1. 
+Missing no-throw guarantees: data() and c_str() simply return
+a pointer to their guts, which is a non-failure operation. This should
+be spelled out. It is also noteworthy to mention that the same
+guarantees should also be given by the size query functions,
+because the combination of pointer to content and the length is
+typically needed during interaction with low-level API.
+
          2. 
+
        2. 
+Missing complexity guarantees: data() and c_str() simply return
+a pointer to their guts, which is guaranteed O(1). This should be
+spelled out.
+
          3. 
+
        3. 
+Missing reading access to the terminating character: Only the
+const overload of operator[] allows reading access to the terminator
+char. For more intuitive usage of strings, reading access to this
+position should be extended to the non-const case. In contrast
+to C++03 this reading access should now be homogeneously
+an lvalue access.
+
          4. 
+
        
+
+
        
+The proposed resolution is split into a main part (A) and a
+secondary part (B) (earlier called "Adjunct Adjunct Proposal").
+(B) extends (A) by also making access to index position
+size() of the at() overloads a no-throw operation. This was
+separated, because this part is theoretically observable in
+specifically designed test programs.
+
        
+
+
        [
+San Francisco:
+]
        
+
+
+
        
+
        
+We oppose part 1 of the issue but hope to address size() in
+issue 877.
+
        
+
        
+We do not support part B. 4 of the issue because of the breaking API change.
+
        
+
        
+We support part A. 2 of the issue.
+
        
+
        
+On support part A. 3 of the issue:
+
        
+
        
+Pete's broader comment: now that we know that basic_string will be a
+block of contiguous memory, we should just rewrite its specification
+with that in mind. The expression of the specification will be simpler
+and probably more correct as a result.
+
        
+
        
+
+
        [
+2009-07 Frankfurt
+]
        
+
+
+
        
+
        
+Move proposed resolution A to Ready.
+
        
+
        [
+Howard: Commented out part B.
+]
        
+
+
        
+
+
+
+
        Proposed resolution:
        
+
          
+
        1. 
+
            
+
          1. 
+
            In 21.4.4 [string.capacity], just after p. 1 add a new paragraph:
+
            
+
            
+Throws: Nothing.
+
            
+
+
            2. 
+
          2. 
+
            
+In 21.4.5 [string.access] replace p. 1 by the following 4 paragraghs:
+
            
+
+
            
+
            
+Requires: pos ≤ size().
+
            
+
            
+Returns: If pos < size(), returns *(begin() + pos). Otherwise, returns
+a reference to a charT() that shall not be modified.
+
            
+
            
+Throws: Nothing.
+
            
+
            
+Complexity: Constant time.
+
            
+
            
+
+
            3. 
+
          3. 
+
            
+In 21.4.7.1 [string.accessors] replace the now common returns
+clause of c_str() and data() by the following three paragraphs:
+
            
+
            
+
            
+Returns: A pointer p such that p+i == &operator[](i) for each i
+in [0, size()].
+
            
+
            
+Throws: Nothing.
+
            
+
            
+Complexity: Constant time.
+
            
+
            
+
            4. 
+
          
+
          2. 
+
+
        
+
+
+
+
+
+
 
        
 
        878. forward_list preconditions
        
 
        Section: 23.3.3 [forwardlist] Status: WP
@@ -35910,6 +39345,76 @@ dereferenceable
 
 
 
+
        
+
        881. shared_ptr conversion issue
        
+
        Section: 20.8.15.2.1 [util.smartptr.shared.const] Status: WP
+ Submitter: Peter Dimov Opened: 2008-08-30  Last modified: 2009-10-26
        
+
        View all other issues in [util.smartptr.shared.const].
        
+
        View all issues with WP status.
        
+
        Discussion:
        
+
        
+We've changed shared_ptr<Y> to not convert to shared_ptr<T> when Y*
+doesn't convert to T* by resolving issue 687. This only fixed the
+converting copy constructor though.
+N2351
+later added move support, and
+the converting move constructor is not constrained.
+
        
+
+
        [
+San Francisco:
+]
        
+
+
+
        
+We might be able to move this to NAD, Editorial once shared_ptr is
+conceptualized, but we want to revisit this issue to make sure.
+
        
+
+
        [
+2009-07 Frankfurt
+]
        
+
+
+
        
+
        
+Moved to Ready.
+
        
+
        
+This issue now represents the favored format for specifying constrained templates.
+
        
+
        
+
+
+
+
        Proposed resolution:
        
+
        
+We need to change the Requires clause of the move constructor:
+
        
+
+
        shared_ptr(shared_ptr&& r); 
+template<class Y> shared_ptr(shared_ptr<Y>&& r); 
+
        
+
        
+Requires Remarks: For the second constructor Y* shall be
+convertible to T*.
+
+The second constructor shall not participate in overload resolution
+unless Y* is convertible to T*.
+
+
        
+
        
+
+
        
+in order to actually make the example in 687 compile
+(it now resolves to the move constructor).
+
        
+
+
+
+
+
+
 
        
 
        882. duration non-member arithmetic requirements
        
 
        Section: 20.9.3.5 [time.duration.nonmember] Status: CD1
@@ -36112,6 +39617,198 @@ be an instantiation of duration. Diagnostic required.
 
 
 
+
        
+
        883. swap circular definition
        
+
        Section: 23 [containers] Status: WP
+ Submitter: Alisdair Meredith Opened: 2008-09-10  Last modified: 2009-10-26
        
+
        View other active issues in [containers].
        
+
        View all other issues in [containers].
        
+
        View all issues with WP status.
        
+
        Discussion:
        
+
+
        
+Note in particular that Table 90 "Container Requirements" gives
+semantics of a.swap(b) as swap(a,b), yet for all
+containers we define swap(a,b) to call a.swap(b) - a
+circular definition.
+
        
+
+
        [
+San Francisco:
+]
        
+
+
+
        
+Robert to propose a resolution along the lines of "Postcondition: "a =
+b, b = a" This will be a little tricky for the hash containers, since
+they don't have operator==.
+
        
+
+
        [
+Post Summit Anthony Williams provided proposed wording.
+]
        
+
+
+
        [
+2009-07 Frankfurt
+]
        
+
+
+
        
+Moved to Ready with minor edits (which have been made).
+
        
+
+
+
+
        Proposed resolution:
        
+
        
+In table 80 in section 23.2.1 [container.requirements.general],
+replace the postcondition of a.swap(b) with the following:
+
        
+
+
        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
        Table 80 -- Container requirements
        ExpressionReturn typeOperational semanticsAssertion/note pre-/post-conidtionComplexity
        ...............
        a.swap(b);void swap(a,b)
+Exchange the contents of a and b.(Note A)
        
+
        
+
+
        
+Remove the reference to swap from the paragraph following the table.
+
        
+
+
        
+Notes: the algorithms swap(), equal() and
+lexicographical_compare() are defined in Clause 25. ...
+
        
+
+
+
+
+
+
        
+
        886. tuple construction
        
+
        Section: 20.5.2.1 [tuple.cnstr] Status: WP
+ Submitter: Alisdair Meredith Opened: 2008-09-15  Last modified: 2009-10-26
        
+
        View all other issues in [tuple.cnstr].
        
+
        View all issues with WP status.
        
+
        Discussion:
        
+
        
+20.5.2.1 [tuple.cnstr]:
+
        
+
        
+Effects: Default initializes each element.
+
        
+
+
        
+Could be clarified to state each "non-trivial" element.  Otherwise
+we have a conflict with Core deinfition of default initialization -
+trivial types do not get initialized (rather than initialization
+having no effect)
+
        
+
+
        
+I'm going to punt on this one, because it's not an issue that's
+related to concepts. I suggest bringing it to Howard's attention on
+the reflector.
+
        
+
+
        [
+San Francisco:
+]
        
+
+
+
        
+
        
+Text in draft doesn't mean anything, changing to "non-trivial" makes it
+meaningful.
+
        
+
        
+We prefer "value initializes". Present implementations use
+value-initialization. Users who don't want value initialization have
+alternatives.
+
        
+
        
+Request resolution text from Alisdair.
+
        
+
+
        
+This issue relates to Issue 868 default construction and value-initialization.
+
        
+
        
+
+
        [
+2009-05-04 Alisdair provided wording and adds:
+]
        
+
+
+
        
+
        
+Note: This IS a change of semantic from TR1, although one the room agreed
+with during the discussion.  To preserve TR1 semantics, this would have been
+worded:
+
        
+
        requires DefaultConstructible<Types>... tuple();
+
        
+
        
+-2-   Effects: Default-initializes each non-trivial element.
+
        
+
        
+
+
+
        
+
+
        [
+2009-07 Frankfurt
+]
        
+
+
+
        
+Move to Ready.
+
        
+
+
+
+
        Proposed resolution:
        
+
        
+Change p2 in Construction 20.5.2.1 [tuple.cnstr]:
+
        
+
+
        requires DefaultConstructible<Types>... tuple();
+
        
+
        
+
        
+-2- Effects: Default Value-initializes each element.
+
        
+
        
+
        
+
+
+
+
+
+
 
        
 
        888. this_thread::yield too strong
        
 
        Section: 30.3.2 [thread.thread.this] Status: WP
@@ -36285,7 +39982,7 @@ been implemented. Seems to be widespread consensus. Move to Tentative Ready.
 
 
        Proposed resolution:
        
 
-
        Change 17.6.4.12 [value.error.codes] Value of error codes as indicated:
        
+
        Change 17.6.4.13 [value.error.codes] Value of error codes as indicated:
        
 
        
  
        Certain functions in the C++ standard library report errors via a 
  std::error_code (19.4.2.2) object. That object's category() member shall 
@@ -36366,7 +40063,7 @@ Thus implementations are given latitude in determining correspondence.
 
 
        
 
-
        Change 19.5.2.3 [syserr.errcode.constructors] Class error_code constructors 
+
        Change 19.5.2.2 [syserr.errcode.constructors] Class error_code constructors 
 as indicated:
        
 
        
  
        error_code();
        
@@ -36375,7 +40072,7 @@ as indicated:
        
  
        Postconditions: val_ == 0 and cat_ == &system_category().
        
  
        
 
      
-
      Change 19.5.2.4 [syserr.errcode.modifiers] Class error_code modifiers as 
+
      Change 19.5.2.3 [syserr.errcode.modifiers] Class error_code modifiers as 
 indicated:
      
 
      
  
      void clear();
      
@@ -36384,7 +40081,7 @@ indicated:
      
  system_category().
      
  
      
 
      5. 
-
      Change 19.5.2.6 [syserr.errcode.nonmembers] Class error_code non-member 
+
      Change 19.5.2.5 [syserr.errcode.nonmembers] Class error_code non-member 
 functions as indicated:
      
 
      
  
      error_code make_error_code(errc e);
      
@@ -36392,7 +40089,7 @@ functions as indicated:
      
  
      Returns: error_code(static_cast<int>(e), generic_category()).
      
  
      
 
    
-
    Change 19.5.3.3 [syserr.errcondition.constructors] Class error_condition 
+
    Change 19.5.3.2 [syserr.errcondition.constructors] Class error_condition 
 constructors as indicated:
    
 
    
  
    error_condition();
    
@@ -36401,7 +40098,7 @@ constructors as indicated:
    
  
    Postconditions: val_ == 0 and cat_ == &generic_category().
    
  
    
 
    
-
    Change 19.5.3.4 [syserr.errcondition.modifiers] Class error_condition 
+
    Change 19.5.3.3 [syserr.errcondition.modifiers] Class error_condition 
 modifiers as indicated:
    
 
    
  
    void clear();
    
@@ -36410,7 +40107,7 @@ modifiers as indicated:
    
  generic_category().
    
  
    
 
    
-
    Change 19.5.3.6 [syserr.errcondition.nonmembers] Class error_condition 
+
    Change 19.5.3.5 [syserr.errcondition.nonmembers] Class error_condition 
 non-member functions as indicated:
    
 
    
  
    error_condition make_error_condition(errc e);
    
@@ -36506,7 +40203,6 @@ any automatic objects.
 
    898. Small contradiction in n2723 to forward to committee
    
 
    Section: 23.3.3.5 [forwardlist.ops] Status: WP
  Submitter: Arch Robison Opened: 2008-09-08  Last modified: 2009-07-18
    
-
    View other active issues in [forwardlist.ops].
    
 
    View all other issues in [forwardlist.ops].
    
 
    View all issues with WP status.
    
 
    Discussion:
    
@@ -36563,7 +40259,7 @@ comparisons.
 
 
    
 
    899. Adjusting shared_ptr for nullptr_t
    
-
    Section: 20.8.10.2.2 [util.smartptr.shared.dest] Status: WP
+
    Section: 20.8.15.2.2 [util.smartptr.shared.dest] Status: WP
  Submitter: Peter Dimov Opened: 2008-09-18  Last modified: 2009-07-18
    
 
    View all other issues in [util.smartptr.shared.dest].
    
 
    View all issues with WP status.
    
@@ -36574,13 +40270,13 @@ James Dennett, message c++std-lib-22442:
 
    
 The wording below addresses one case of this, but opening an
 issue to address the need to sanity check uses of the term "pointer"
-in 20.8.10.2 [util.smartptr.shared] would be a good thing.
+in 20.8.15.2 [util.smartptr.shared] would be a good thing.
 
    
 
    
 There's one more reference, in ~shared_ptr; we can apply your suggested change to it, too. That is:
 
    
 
    
-Change 20.8.10.2.2 [util.smartptr.shared.dest]/1 second bullet from:
+Change 20.8.15.2.2 [util.smartptr.shared.dest]/1 second bullet from:
 
    
 
    
 Otherwise, if *this owns a pointer p and a deleter d, d(p) is called.
@@ -36609,7 +40305,7 @@ Batavia (2009-05):
 
    
 Peter Dimov notes the analogous change has already been made
 to "the new nullptr_t taking constructors
-in 20.8.10.2.1 [util.smartptr.shared.const] p9-13."
+in 20.8.15.2.1 [util.smartptr.shared.const] p9-13."
 
    
 
    
 We agree with the proposed resolution.
@@ -36620,7 +40316,7 @@ Move to Tentatively Ready.
 
 
    Proposed resolution:
    
 
    
-Change 20.8.10.2.2 [util.smartptr.shared.dest]/1 second bullet:
+Change 20.8.15.2.2 [util.smartptr.shared.dest]/1 second bullet:
 
    
 
    
 
      
@@ -36641,6 +40337,7 @@ deleter d, d(p) is called.
 
      904. result_of argument types
      
 
      Section: 20.7.4 [func.ret] Status: WP
  Submitter: Jonathan Wakely Opened: 2008-09-10  Last modified: 2009-07-18
      
+
      View all other issues in [func.ret].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
 
      
@@ -36707,7 +40404,7 @@ and rvalues otherwise.
 
 
      
 
      907. Bitset's immutable element retrieval is inconsistently defined
      
-
      Section: 20.3.6.2 [bitset.members] Status: WP
+
      Section: 20.3.7.2 [bitset.members] Status: WP
  Submitter: Daniel Krügler Opened: 2008-09-26  Last modified: 2009-07-18
      
 
      View all other issues in [bitset.members].
      
 
      View all issues with WP status.
      
@@ -36716,8 +40413,8 @@ and rvalues otherwise.
 The current standard 14882::2003(E) as well as the current draft
 N2723
 have in common a contradiction of the operational semantics
-of member function test 20.3.6.2 [bitset.members]/56-58 and the immutable
-member operator[] overload 20.3.6.2 [bitset.members]/64-66 (all references
+of member function test 20.3.7.2 [bitset.members]/56-58 and the immutable
+member operator[] overload 20.3.7.2 [bitset.members]/64-66 (all references
 are defined in terms of
 N2723):
 
      
@@ -36799,8 +40496,8 @@ Proposed alternatives:
 
      
 Remove the constexpr specifier in front of operator[] overload and
 undo that of member test (assuming 720 is accepted) in both the
-class declaration 20.3.6 [template.bitset]/1 and in the member description
-before 20.3.6.2 [bitset.members]/56 and before /64 to read:
+class declaration 20.3.7 [template.bitset]/1 and in the member description
+before 20.3.7.2 [bitset.members]/56 and before /64 to read:
 
      
 
      constexpr bool test(size_t pos) const;
 ..
@@ -36830,8 +40527,8 @@ position nothing.
 
    • 
 
      
 Undo the addition of the constexpr specifier to the test member
-function in both class declaration 20.3.6 [template.bitset]/1 and in the
-member description before 20.3.6.2 [bitset.members]/56, assuming that 720
+function in both class declaration 20.3.7 [template.bitset]/1 and in the
+member description before 20.3.7.2 [bitset.members]/56, assuming that 720
 was applied.
 
      
 
@@ -36879,8 +40576,8 @@ Move to Tentatively Ready.
 
    • 
 
      
 Undo the addition of the constexpr specifier to the test member
-function in both class declaration 20.3.6 [template.bitset]/1 and in the
-member description before 20.3.6.2 [bitset.members]/56, assuming that 720
+function in both class declaration 20.3.7 [template.bitset]/1 and in the
+member description before 20.3.7.2 [bitset.members]/56, assuming that 720
 was applied.
 
      
 
@@ -37057,7 +40754,7 @@ by the iterator range [&submatches,&submatches + N)
 
      Addresses DE 24
      
 
 
      
-With respect to the section 20.7.12.1.4 [func.bind.place]:
+With respect to the section 20.7.11.1.4 [func.bind.place]:
 
      
 
      
 TR1 dropped some suggested implementation quantities for the number of
@@ -37082,7 +40779,7 @@ Tentatively Ready.
 Original proposed resolution:
 
 
      
-Add 20.7.12.1.4 [func.bind.place]/2:
+Add 20.7.11.1.4 [func.bind.place]/2:
 
      
 
 
      
@@ -37100,7 +40797,7 @@ Add to B [implimits]:
 
 
        
 
      • 
-Number of placeholders (20.7.12.1.4 [func.bind.place]) [10].
+Number of placeholders (20.7.11.1.4 [func.bind.place]) [10].
 
        • 
 
      
 
@@ -37111,16 +40808,15 @@ Number of placeholders (20.7.12.1.4 [func.bind.place]) [10].
 
 
      
 
      925. shared_ptr's explicit conversion from unique_ptr
      
-
      Section: 20.8.10.2.1 [util.smartptr.shared.const] Status: WP
+
      Section: 20.8.15.2.1 [util.smartptr.shared.const] Status: WP
  Submitter: Rodolfo Lima Opened: 2008-10-12  Last modified: 2009-07-18
      
-
      View other active issues in [util.smartptr.shared.const].
      
 
      View all other issues in [util.smartptr.shared.const].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
 
      
 The current working draft
 (N2798),
-section 20.8.10.2.1 [util.smartptr.shared.const] declares
+section 20.8.15.2.1 [util.smartptr.shared.const] declares
 shared_ptr's constructor that takes a rvalue reference to unique_ptr and
 auto_ptr as being explicit, affecting several valid smart pointer use
 cases that would take advantage of this conversion being implicit, for
@@ -37181,8 +40877,8 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-In both 20.8.10.2 [util.smartptr.shared] paragraph 1 and 
-20.8.10.2.1 [util.smartptr.shared.const] change:
+In both 20.8.15.2 [util.smartptr.shared] paragraph 1 and 
+20.8.15.2.1 [util.smartptr.shared.const] change:
 
      
 
 
      template <class Y> explicit shared_ptr(auto_ptr<Y> &&r);
@@ -37291,9 +40987,186 @@ Wording supplied by Daniel.
 
 
 
+
      
+
      934. duration is missing operator%
      
+
      Section: 20.9.3 [time.duration] Status: WP
+ Submitter: Terry Golubiewski Opened: 2008-11-30  Last modified: 2009-10-26
      
+
      View other active issues in [time.duration].
      
+
      View all other issues in [time.duration].
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
+
      Addresses US 81
      
+
+
      
+duration is missing operator%.  This operator is convenient
+for computing where in a time frame a given duration lies.  A
+motivating example is converting a duration into a "broken-down"
+time duration such as hours::minutes::seconds:
+
      
+
+
      class ClockTime
+{
+    typedef std::chrono::hours hours;
+    typedef std::chrono::minutes minutes;
+    typedef std::chrono::seconds seconds;
+public:
+    hours hours_;
+    minutes minutes_;
+    seconds seconds_;
+
+    template <class Rep, class Period>
+      explicit ClockTime(const std::chrono::duration<Rep, Period>& d)
+        : hours_  (std::chrono::duration_cast<hours>  (d)),
+          minutes_(std::chrono::duration_cast<minutes>(d % hours(1))),
+          seconds_(std::chrono::duration_cast<seconds>(d % minutes(1)))
+          {}
+};
+
      
+
+
      [
+Summit:
+]
      
+
+
+
      
+Agree except that there is a typo in the proposed resolution. The member
+operators should be operator%=.
+
      
+
+
      [
+Batavia (2009-05):
+]
      
+
+
      
+We agree with the proposed resolution.
+Move to Tentatively Ready.
+
      
+
+
      [
+2009-07 Frankfurt
+]
      
+
+
+
      
+Moved from Tentatively Ready to Open only because the wording needs to be
+improved for enable_if type constraining, possibly following Robert's
+formula.
+
      
+
+
      [
+2009-07 Frankfurt:
+]
      
+
+
+
      
+
      
+Howard to open a separate issue (1177) to handle the removal of member
+functions from overload sets, provide wording, and possibly demonstrate
+how this can be implemented using enable_if (see 947).
+
      
+
      
+Move to Ready.
+
      
+
      
+
+
+
+
      Proposed resolution:
      
+
      
+Add to the synopsis in 20.9 [time]:
+
      
+
+
      template <class Rep1, class Period, class Rep2>
+  duration<typename common_type<Rep1, Rep2>::type, Period>
+  operator%(const duration<Rep1, Period>& d, const Rep2& s);
+template <class Rep1, class Period1, class Rep2, class Period2>
+  typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
+  operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
      
+
+
      
+Add to the synopsis of duration in 20.9.3 [time.duration]:
+
      
+
+
      template <class Rep, class Period = ratio<1>>
+class duration {
+public:
+  ...
+  duration& operator%=(const rep& rhs);
+  duration& operator%=(const duration& d);
+  ...
+};
+
      
+
+
      
+Add to 20.9.3.3 [time.duration.arithmetic]:
+
      
+
+
      
+
      duration& operator%=(const rep& rhs);
+
      
+
      
+
      
+Effects: rep_ %= rhs.
+
      
+
      
+Returns: *this.
+
      
+
      
+
+
      duration& operator%=(const duration& d);
+
      
+
      
+
      
+Effects: rep_ %= d.count().
+
      
+
      
+Returns: *this.
+
      
+
      
+
      
+
+
      
+Add to 20.9.3.5 [time.duration.nonmember]:
+
      
+
+
      
+
+
      template <class Rep1, class Period, class Rep2>
+  duration<typename common_type<Rep1, Rep2>::type, Period>
+  operator%(const duration<Rep1, Period>& d, const Rep2& s);
+
      
+
      
+
      
+Requires: Rep2 shall be implicitly convertible to CR(Rep1, Rep2) and
+Rep2 shall not be an instantiation of duration. Diagnostic required.
+
      
+
      
+Returns: duration<CR, Period>(d) %= s.
+
      
+
      
+
+
      template <class Rep1, class Period1, class Rep2, class Period2>
+  typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
+  operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
+
      
+
      
+
      
+Returns: common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type(lhs) %= rhs.
+
      
+
      
+
+
      
+
+
+
+
+
+
 
      
 
      938. default_delete<T[]>::operator() should only accept T*
      
-
      Section: 20.8.9.1.2 [unique.ptr.dltr.dflt1] Status: WP
+
      Section: 20.8.14.1.2 [unique.ptr.dltr.dflt1] Status: WP
  Submitter: Howard Hinnant Opened: 2008-12-07  Last modified: 2009-07-18
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -37332,7 +41205,7 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Add to 20.8.9.1.2 [unique.ptr.dltr.dflt1]:
+Add to 20.8.14.1.2 [unique.ptr.dltr.dflt1]:
 
      
 
 
      namespace std {
@@ -37508,12 +41381,12 @@ If overflow occurs, a diagnostic shall be issued.
 
 
      
 
      949. owner_less
      
-
      Section: 20.8.10.4 [util.smartptr.ownerless] Status: WP
+
      Section: 20.8.15.3.7 [util.smartptr.ownerless] Status: WP
  Submitter: Thomas Plum Opened: 2008-12-30  Last modified: 2009-07-18
      
 
      View all issues with WP status.
      
 
      Discussion:
      
 
      
-20.8.10.4 [util.smartptr.ownerless] (class template owner_less) says that 
+20.8.15.3.7 [util.smartptr.ownerless] (class template owner_less) says that 
 operator()(x,y) shall return x.before(y).
 
      
 
      
@@ -37547,7 +41420,7 @@ Recommend Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Change 20.8.10.4 [util.smartptr.ownerless] p2:
+Change 20.8.15.3.7 [util.smartptr.ownerless] p2:
 
      
 
 
      
@@ -37624,13 +41497,11 @@ previously-initialized but as of yet undestroyed
 
 
      
 
      970. addressof overload unneeded
      
-
      Section: 20.8.8.1 [object.addressof] Status: WP
- Submitter: Howard Hinnant Opened: 2009-01-16  Last modified: 2009-07-18
      
-
      View all other issues in [object.addressof].
      
-
      View all issues with WP status.
      
+
      Section: X [object.addressof] Status: Pending WP
+ Submitter: Howard Hinnant Opened: 2009-01-16  Last modified: 2009-09-25
      
 
      Discussion:
      
 
      
-20.8.8.1 [object.addressof] specifies:
+X [object.addressof] specifies:
 
      
 
 
      template <ObjectType T> T* addressof(T& r);
@@ -37664,7 +41535,7 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Change 20.8.8.1 [object.addressof]:
+Change X [object.addressof]:
 
      
 
 
      template <ObjectType T> T* addressof(T& r);
@@ -38056,6 +41927,7 @@ In 23.2.5 [unord.req], Table 87 insert:
 
      982. Wrong complexity for initializer_list assignment in  Table 85
      
 
      Section: 23.2.4 [associative.reqmts] Status: WP
  Submitter: Daniel Krügler Opened: 2009-02-08  Last modified: 2009-07-18
      
+
      View other active issues in [associative.reqmts].
      
 
      View all other issues in [associative.reqmts].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -38431,7 +42303,7 @@ functions passed to atexit() (3.6.3 [basic.start.term]).
 
 
      
 
      994. Response to UK 193
      
-
      Section: 18.6.2.2 [new.handler] Status: WP
+
      Section: 18.6.2.3 [new.handler] Status: WP
  Submitter: P.J. Plauger Opened: 2009-03-03  Last modified: 2009-07-18
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -38452,7 +42324,7 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Change 18.6.2.2 [new.handler], p2:
+Change 18.6.2.3 [new.handler], p2:
 
      
 
 
      
@@ -38596,7 +42468,7 @@ supersedes any occurrences of that element in the code-sequence.
 
 
      
 
      998. Smart pointer referencing its owner
      
-
      Section: 20.8.9.2.5 [unique.ptr.single.modifiers] Status: WP
+
      Section: 20.8.14.2.5 [unique.ptr.single.modifiers] Status: WP
  Submitter: Pavel Minaev Opened: 2009-02-26  Last modified: 2009-07-18
      
 
      View all other issues in [unique.ptr.single.modifiers].
      
 
      View all issues with WP status.
      
@@ -38723,7 +42595,7 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Change 20.8.9.2.5 [unique.ptr.single.modifiers], p5 (Effects clause for reset), and p6:
+Change 20.8.14.2.5 [unique.ptr.single.modifiers], p5 (Effects clause for reset), and p6:
 
      
 
 
      
@@ -38747,6 +42619,65 @@ expression. -- end note]
 
 
 
+
      
+
      1004. Response to UK 179
      
+
      Section: 17.6.3.8 [res.on.functions] Status: WP
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-26
      
+
      View all other issues in [res.on.functions].
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
+
      Addresses UK 179
      
+
+
      
+According to the 4th bullet there is a problem if "if any replacement
+function or handler function or destructor operation throws an
+exception". There should be no problem throwing exceptions so long as
+they are caught within the function.
+
      
+
+
      [
+Batavia (2009-05):
+]
      
+
+
      
+The phrasing "throws an exception" is commonly used elsewhere
+to mean "throws or propagates an exception."
+Move to Open pending a possible more general resolution.
+
      
+
+
      [
+2009-07 Frankfurt:
+]
      
+
+
+
      
+Replace "propagates" in the proposed resolution with the phrase "exits
+via" and move to Ready.
+
      
+
+
+
+
      Proposed resolution:
      
+
      
+Change the 4th bullet of 17.6.3.8 [res.on.functions], p2:
+
      
+
+
      
+
        
+
      • 
+if any replacement function or handler function or destructor operation
+throws exits via an exception, unless specifically
+allowed in the applicable Required behavior: paragraph.
+
        • 
+
      
+
      
+
+
+
+
+
+
 
      
 
      1006. operator delete in garbage collected implementation
      
 
      Section: 18.6.1 [new.delete] Status: WP
@@ -38913,6 +42844,112 @@ be a safely-derived pointer.
 
 
 
+
      
+
      1012. reverse_iterator default ctor should value initialize
      
+
      Section: 24.5.1.3.1 [reverse.iter.cons] Status: WP
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-26
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
+
      Addresses UK 277
      
+
+
      
+The default constructor default-initializes current, rather than
+value-initializes. This means that when Iterator corresponds to a
+trivial type, the current member is left un-initialized, even when the
+user explictly requests value intialization! At this point, it is not
+safe to perform any operations on the reverse_iterator other than assign
+it a new value or destroy it. Note that this does correspond to the
+basic definition of a singular iterator.
+
      
+
+
      [
+Summit:
+]
      
+
+
+
      
+Agree with option i.
+
      
+
+
      
+Related issue: 408
+
      
+
+
      [
+Batavia (2009-05):
+]
      
+
+
      
+We believe this should be revisited
+in conjunction with issue 408,
+which nearly duplicates this issue.
+Move to Open.
+
      
+
+
      [
+2009-07 post-Frankfurt:
+]
      
+
+
+
      
+
      
+Change "constructed" to "initialized" in two places in the proposed resolution.
+
      
+
      
+Move to Tentatively Ready.
+
      
+
      
+
+
      [
+2009 Santa Cruz:
+]
      
+
+
+
      
+Moved to Ready for this meeting.
+
      
+
+
+
+
      Proposed resolution:
      
+
      
+Change  [reverse.iter.con]:
+
      
+
+
      reverse_iterator();
+
      
+
      
+-1- Effects: Default Value initializes current. Iterator
+operations applied to the resulting iterator have defined behavior if and
+only if the corresponding operations are defined on a default constructed
+value initialized
+iterator of type Iterator.
+
      
+
      
+
+
      
+Change 24.5.3.3.1 [move.iter.op.const]:
+
      
+
+
      move_iterator();
+
      
+
      
+-1- Effects: Constructs a move_iterator, default value
+initializing current.
+Iterator
+operations applied to the resulting iterator have defined behavior if and
+only if the corresponding operations are defined on a
+value initialized
+iterator of type Iterator.
+
      
+
      
+
+
+
+
+
+
 
      
 
      1014. Response to UK 317 and JP 74
      
 
      Section: 28.8.2 [re.regex.construct] Status: WP
@@ -38989,9 +43026,121 @@ Add in  28.8.2 [re.regex.construct]:
 
 
 
+
      
+
      1019. Response to UK 205
      
+
      Section: 20.6.3 [meta.help] Status: WP
+ Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-10-26
      
+
      View all other issues in [meta.help].
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
+
      Addresses UK 205
      
+
+
      
+integral_constant objects should be usable in integral-constant-expressions.
+The addition to the language of literal types and the enhanced rules for
+constant expressions make this possible.
+
      
+
+
      [
+Batavia (2009-05):
+]
      
+
+
      
+We agree that the static data member
+ought be declared constexpr,
+but do not see a need for the proposed operator value_type().
+(A use case would be helpful.)
+Move to Open.
+
      
+
+
      [
+2009-05-23 Alisdair adds:
+]
      
+
+
+
      
+
      
+The motivating case in my mind is that we can then use
+true_type and false_type as integral Boolean expressions, for example inside
+a static_assert declaration.  In that sense it is purely a matter of style.
+
      
+
      
+Note that Boost has applied the non-explicit conversion operator for many
+years as it has valuable properties for extension into other metaprogramming
+libraries, such as MPL.  If additional rationale is desired I will poll the
+Boost lists for why this extension was originally applied.  I would argue
+that explicit conversion is more appropriate for 0x though.
+
      
+
      
+
+
      [
+2009-07-04 Howard adds:
+]
      
+
+
+
      
+
      
+Here's a use case which demonstrates the syntactic niceness which Alisdair describes:
+
      
+
+
      #define requires(...) class = typename std::enable_if<(__VA_ARGS__)>::type
+
+template <class T, class U,
+    requires(!is_lvalue_reference<T>() ||
+              is_lvalue_reference<T>() && is_lvalue_reference<U>()),
+    requires(is_same<typename base_type<T>::type,
+                     typename base_type<U>::type>)>
+inline
+T&&
+forward(U&& t)
+{
+    return static_cast<T&&>(t);
+}
+
      
+
      
+
+
      [
+2009-07 post-Frankfurt:
+]
      
+
+
+
      
+Move to Tentatively Ready.
+
      
+
+
      [
+2009 Santa Cruz:
+]
      
+
+
+
      
+Moved to Ready for this meeting.
+
      
+
+
+
+
      Proposed resolution:
      
+
      
+Add to the integral_constant struct definition in 20.6.3 [meta.help]:
+
      
+
+
      template <class T, T v>
+struct integral_constant {
+  static constexpr T value = v;
+  typedef T value_type;
+  typedef integral_constant<T,v> type;
+  constexpr operator value_type() { return value; }
+};
+
      
+
+
+
+
+
 
      
 
      1021. Response to UK 211
      
-
      Section: 20.8.9.2.3 [unique.ptr.single.asgn] Status: WP
+
      Section: 20.8.14.2.3 [unique.ptr.single.asgn] Status: WP
  Submitter: Alisdair Meredith Opened: 2009-03-11  Last modified: 2009-07-18
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -39016,14 +43165,14 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Change the synopsis in 20.8.9.2 [unique.ptr.single]:
+Change the synopsis in 20.8.14.2 [unique.ptr.single]:
 
      
 
 
      unique_ptr& operator=(unspecified-pointer-type nullptr_t);
 
      
 
 
      
-Change 20.8.9.2.3 [unique.ptr.single.asgn]:
+Change 20.8.14.2.3 [unique.ptr.single.asgn]:
 
      
 
 
      unique_ptr& operator=(unspecified-pointer-type nullptr_t);
@@ -39044,6 +43193,7 @@ private data member, avoiding many of the implicit conversion pitfalls.
 
      1037. Response to UK 232
      
 
      Section: 23.2.3 [sequence.reqmts] Status: WP
  Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
      
+
      View other active issues in [sequence.reqmts].
      
 
      View all other issues in [sequence.reqmts].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -39092,6 +43242,7 @@ In 23.2.3 [sequence.reqmts] Table 84, remove reference to
 
      1038. Response to UK 233
      
 
      Section: 23.2.3 [sequence.reqmts] Status: WP
  Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
      
+
      View other active issues in [sequence.reqmts].
      
 
      View all other issues in [sequence.reqmts].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -39195,6 +43346,7 @@ containers to the following rows:
 
      1039. Response to UK 234
      
 
      Section: 23.2.3 [sequence.reqmts] Status: WP
  Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
      
+
      View other active issues in [sequence.reqmts].
      
 
      View all other issues in [sequence.reqmts].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -39258,6 +43410,7 @@ In 23.2.3 [sequence.reqmts] Table 84, replace iterator with auto in semantics fo
 
      1040. Response to UK 238
      
 
      Section: 23.2.4 [associative.reqmts] Status: WP
  Submitter: Alisdair Meredith Opened: 2009-03-12  Last modified: 2009-07-18
      
+
      View other active issues in [associative.reqmts].
      
 
      View all other issues in [associative.reqmts].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
@@ -39603,13 +43756,13 @@ In the synopsis of 18.8.6 [except.nested] and the definition area change:
 
 
      
 
      1070. Ambiguous move overloads in function
      
-
      Section: 20.7.16.2 [func.wrap.func] Status: WP
+
      Section: 20.7.15.2 [func.wrap.func] Status: WP
  Submitter: Howard Hinnant Opened: 2009-03-19  Last modified: 2009-07-18
      
 
      View all other issues in [func.wrap.func].
      
 
      View all issues with WP status.
      
 
      Discussion:
      
 
      
-The synopsis in 20.7.16.2 [func.wrap.func] says:
+The synopsis in 20.7.15.2 [func.wrap.func] says:
 
      
 
 
      template<Returnable R, CopyConstructible... ArgTypes> 
@@ -39673,8 +43826,8 @@ Move to Tentatively Ready.
 
 
      Proposed resolution:
      
 
      
-Change the synopsis of 20.7.16.2 [func.wrap.func], and remove the associated definitions in
-20.7.16.2.1 [func.wrap.func.con]:
+Change the synopsis of 20.7.15.2 [func.wrap.func], and remove the associated definitions in
+20.7.15.2.1 [func.wrap.func.con]:
 
      
 
 
      template<Returnable R, CopyConstructible... ArgTypes> 
@@ -39997,4 +44150,38 @@ need not be repeated here).
 
 
 
+
      
+
      1178. Header dependencies
      
+
      Section: 17.6.4.2 [res.on.headers] Status: WP
+ Submitter: Beman Dawes Opened: 2009-07-18  Last modified: 2009-10-26
      
+
      View all issues with WP status.
      
+
      Discussion:
      
+
      
+See Frankfurt notes of 1001.
+
      
+
+
+
      Proposed resolution:
      
+
      Change 17.6.4.2 [res.on.headers], Headers, paragraph 1, as indicated:
      
+
+
      
+
+
      
+A C++ header may include other C++
+headers.[footnote] A C++ header shall provide
+the declarations and definitions that appear in its synopsis
+(3.2 [basic.def.odr]). A C++ header shown in its synopsis as including 
+other C++ headers shall provide the declarations and definitions that appear in
+the synopses of those other headers.
+
      
+
+  
      [footnote] C++ headers must include a C++ header that contains 
+  any needed definition (3.2).
      
+
      
+
+
+
+
+
+
 
\ No newline at end of file
-- 
cgit v1.2.1