Boost-Commit :

Date view	Thread view	Subject view	Author view

From: dgregor_at_[hidden]
Date: 2008-03-11 14:46:39

Next message: stipe_at_[hidden]: "[Boost-commit] svn:boost r43568 - sandbox/SOC/2007/signals/libs/dataflow/test/utility"
Previous message: kbelco_at_[hidden]: "[Boost-commit] svn:boost r43566 - trunk/tools/build/v2/tools"

Author: dgregor
Date: 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
New Revision: 43567
URL: http://svn.boost.org/trac/boost/changeset/43567

Log:
Provide and integrate proposed resolutions for several concepts issues
Text files modified:
   sandbox/committee/concepts/issues/issues/issue1.xml | 122 +++++++++++++++++
   sandbox/committee/concepts/issues/issues/issue10.xml | 6
   sandbox/committee/concepts/issues/issues/issue17.xml | 32 ++++
   sandbox/committee/concepts/issues/issues/issue4.xml | 22 +++
   sandbox/committee/concepts/issues/issues/issue7.xml | 3
   sandbox/committee/concepts/issues/issues/issue9.xml | 18 ++
   sandbox/committee/concepts/stdlib/clib-algorithms.tex | 2
   sandbox/committee/concepts/stdlib/clib-concepts.tex | 276 ++++++++++++++-------------------------
   sandbox/committee/concepts/stdlib/clib-iterators.tex | 8
   sandbox/committee/concepts/stdlib/clib-numerics.tex | 2
   sandbox/committee/concepts/stdlib/macros.tex | 2
   sandbox/committee/concepts/wording/wording.tex | 2
   12 files changed, 301 insertions(+), 194 deletions(-)

Modified: sandbox/committee/concepts/issues/issues/issue1.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue1.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue1.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
 <!ENTITY nbsp " ">
] >

-<issue num="1" status="New">
+<issue num="1" status="Ready">
 <title>Naming and symmetry in EqualityComparable</title>
 <section><sref ref="[concept.comparison]"/></section>
 <submitter>LWG</submitter>
@@ -36,4 +36,124 @@
 same thing? Is there any way to write defaults in the concept
 definition that won't ever give us an infinite loop?
 </discussion>
+
+ <resolution>
+ Split the <code>EqualityComparable</code>
+ and <code>LessThanComparable</code> concepts into purely syntactic
+ concepts (<code>HasEquals</code>, <code>HasLessThan</code>) and
+ semantic concepts that refine them
+ (<code>EqualityComparable</code>, <code>LessThanComparable</code>). In
+ [utility.concepts], update the <concepts> header synopsis as
+ follows:
+ <pre>
+// 20.1.2, comparisons:
+auto concept LessThanComparable<typename T<del>, typename U = T</del>> see below;
+auto concept EqualityComparable<typename T<del>, typename U = T</del>> see below;
+auto concept TriviallyEqualityComparable<typename T> see below;
+
+...
+// 20.1.10, operator concepts:
+...
+
+auto concept HasNegate<typename T> see below;
+<ins>auto concept HasLess<typename T, typename U = T> see below;</ins>
+<ins>auto concept HasEquals<typename T, typename U = T> see below;</ins>
+auto concept HasLogicalAnd<typename T, typename U = T> see below;
+ </pre>
+ 
+
+ Change [concept.comparison] paragraph 1 as follows:
+ <pre>
+auto concept LessThanComparable<typename T<del>, typename U = T</del>><ins> : HasLess<T></ins> {
+ <del>bool operator<(T const& a, U const& b);</del>
+ bool operator>(<del>U</del><ins>T</ins> const& a, T const& b) { return b < a; }
+ bool operator<=(<del>U</del><ins>T</ins> const& a, T const& b) { return !(b < a); }
+ bool operator>=(T const& a, <del>U</del><ins>T</ins> const& b) { return !(a < b); }
+
+ <ins>axiom Consistency(T a, T b) {
+ (a > b) == (b < a);
+ (a <= b) == !(b < a);
+ (a >= b) == !(a < b);
+ }
+
+ axiom Irreflexivity(T a) { (a < a) == false; }
+
+ axiom Antisymmetry(T a, T b) {
+ if (a < b) (b < a) == false;
+ }
+
+ axiom Transitivity(T a, T b, T c) {
+ if (a 
+}
+ </pre>
+<ol>
+ <li>    <del>Note: describes types whose
+ values can be ordered via an inequality operator.</del></li>
+</ol>
+
+
+ Change [concept.comparison] paragraphs 3 and 4 as follows:
+ <pre>
+auto concept EqualityComparable<typename T<del>, typename U = T</del>><ins> : HasEquals<T></ins> {
+ <del>bool operator==(T const& a, U const& b);</del>
+ bool operator!=(T const& a, <del>U</del><ins>T</ins> const& b) { return !(a == b); }
+
+ <ins>axiom Consistency(T a, T b) {
+ (a == b) == !(a != b);
+ }
+
+ axiom Reflexivity(T a) { a == a; }
+
+ axiom Symmetry(T a, T b) { if (a == b) b == a; }
+
+ axiom Transitivity(T a, T b, T c) {
+ if (a == b && b == c) a == c;
+ }</ins>
+}
+ </pre>
+<ol start="3">
+ <li>    <del>Note: describes types whose
+ values can be compared for equality with <code>operator==</code>.</del></li>
+
+ <li>    Requires: <del>when <code>T</code> and <code>U</code> are identical, </del><code>operator==</code> is an equivalence relation<del> that is, it has the following properties:</del><ins>.</ins>
+ <ul>
+ <li><del>For all a, a == a.</del></li>
+ <li><del>If a == b, then b == a.</del></li>
+ <li><del>If a == b and b == c, then a == c.</del></li>
+ </ul>
+ </li>
+</ol>
+ 
+
+ Add to [concept.operator]:
+ <pre>
+<ins>auto concept HasLess< typename T, typename U = T> {
+ bool operator<(const T& a, const U& b);
+}</ins>
+ </pre>
+ <ol start="8">
+ <li>    <ins>Note: describes types with an <code>operator<</code></ins></li>
+ </ol>
+
+ <pre>
+<ins>auto concept HasEquals< typename T, typename U = T> {
+ bool operator==(const T& a, const U& b);
+}</ins>
+ </pre>
+ <ol start="9">
+ <li>    <ins>Note: describes types with an <code>operator==</code></ins></li>
+ </ol>
+ 
+
+ Note that this change also requires renaming two-parameter uses
+ of <code>EqualityComparable</code>
+ and <code>LessThanComparable</code> to <code>HasEquals</code>
+ and <code>HasLess</code>, respectively.
+ </resolution>
</issue>

Modified: sandbox/committee/concepts/issues/issues/issue10.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue10.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue10.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
<!ENTITY nbsp " ">
] >

-<issue num="10" status="New">
+<issue num="10" status="WP">
<title>Remarks should be notes</title>
<section><sref ref="[utility.concepts]"/></section>
<submitter>LWG</submitter>
@@ -17,4 +17,8 @@
editorial issue.
</discussion>

+<resolution>
+ Replace all "Remark"s in the paper with "Note"s.
+</resolution>
+
</issue>

Modified: sandbox/committee/concepts/issues/issues/issue17.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue17.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue17.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
<!ENTITY nbsp " ">
] >

-<issue num="17" status="New">
+<issue num="17" status="WP">
<title>Errors in Allocator concept</title>
<section><sref ref="[concept.allocator]"/></section>
<submitter>LWG</submitter>
@@ -25,4 +25,34 @@
value_type></tt> as in the synopsis.
</discussion>

+<resolution>
+ In [concept.allocator] paragraph 2, change the associated requirements of
+ the <code>Allocator</code> concept as follows:
+ <pre>
+concept Allocator<typename X> : DefaultConstructible<X>, CopyConstructible<X> {
+ // ...
+ requires Convertible<pointer, const_pointer> &&
+ <del>Convertible<pointer, void*> &&</del>
+ Convertible<pointer, value_type*> &&
+ SameType<pointer::value_type, value_type> &&
+ SameType<pointer::reference, value_type&> &&
+ SameType<pointer::reference, reference>;
+ requires <del>Convertible<const_pointer, const void*> &&</del>
+ Convertible<const_pointer, const value_type<del>&amp</del><ins>*</ins>;> &&
+ SameType<const_pointer::value_type, value_type> &&
+ SameType<const_pointer::reference, const value_type&> &&
+ SameType<const_pointer::reference, const_reference>;
+}
+ </pre>
+ 
+
+ Change [concept.allocator] paragraph 11 as follows:
+ <pre>
+template<typename V>
+ requires Constructible<value_type, V<del>&&</del>>
+ void X::construct(pointer p, V&&);
+ </pre>
+ 
+</resolution>
+
</issue>

Modified: sandbox/committee/concepts/issues/issues/issue4.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue4.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue4.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
<!ENTITY nbsp " ">
] >

-<issue num="4" status="New">
+<issue num="4" status="WP">
<title>MoveConstructible should refine Constructible</title>
<section><sref ref="[concept.copymove]"/></section>
<submitter>LWG</submitter>
@@ -19,4 +19,24 @@
body of <tt>MoveConstructible</tt> would go away.
</discussion>

+<resolution>
+In [concept.copymove] paragraph 1, change as follows:
+<pre>
+auto concept MoveConstructible<typename T> : <ins>Constructible<T, T&&>, </ins>Destructible<T> {
+ <del>T::T(T&&);</del>
+}
+</pre>
+
+In [concept.copymove] paragraph 3, change as follows:
+<pre>
+ auto concept CopyConstructible<typename T> : MoveConstructible<T><ins>, Constructible<T, const T&></ins> {
+ <del>T::T(const T&);</del>
+
+ axiom CopyPreservation(T x) {
+ T(x) == x;
+ }
+}
+</pre>
+</resolution>
+
</issue>

Modified: sandbox/committee/concepts/issues/issues/issue7.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue7.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue7.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
 <!ENTITY nbsp " ">
] >

-<issue num="7" status="New">
+<issue num="7" status="Open">
 <title>Meaning of "equivalent" in <tt>MoveAssignable</tt></title>
 <section><sref ref="[concept.copymove]"/></section>
 <submitter>LWG</submitter>
@@ -20,5 +20,4 @@
 of <tt>operator==</tt>, but this concept doesn't mention that
 operator.)
</discussion>
-
</issue>

Modified: sandbox/committee/concepts/issues/issues/issue9.xml
==============================================================================
--- sandbox/committee/concepts/issues/issues/issue9.xml (original)
+++ sandbox/committee/concepts/issues/issues/issue9.xml 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -3,7 +3,7 @@
<!ENTITY nbsp " ">
] >

-<issue num="9" status="New">
+<issue num="9" status="WP">
<title>Memory-allocation concepts are too fine-grained</title>
<section><sref ref="[concept.memory]"/></section>
<submitter>LWG</submitter>
@@ -20,8 +20,20 @@
</discussion>

<resolution>
-
-
+ In [concept.memory], remove paragraphs 1-4 (describing
+ the <code>Newable</code>, <code>Deletable</code>, <code>ArrayNewable</code>,
+ and <code>ArrayDeletable</code> concepts). Change
+ the <code>HeapAllocatable</code> concept as follows:
+<pre>
+auto concept HeapAllocatable<typename T>
+ <del>: Newable<T>, Deletable<T>, ArrayNewable<T>, ArrayDeletable<T></del> {
+ <ins>void* T::operator new(size_t size);</ins>
+ <ins>void* T::operator new(size_t size, void*);</ins>
+ <ins>void* T::operator new[](size_t size);</ins>
+ <ins>void T::operator delete(void*);</ins>
+ <ins>void T::operator delete[](void*);</ins>
+}
+ </pre>
</resolution>

</issue>

Modified: sandbox/committee/concepts/stdlib/clib-algorithms.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-algorithms.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-algorithms.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -42,7 +42,7 @@
\end{center}

\vspace{1in}
-\par\noindent Document number: DRAFT\vspace{-6pt}
+\par\noindent Document number: D2573=08-0083\vspace{-6pt}
\par\noindent Revises document number: N2084=06-0154\vspace{-6pt}
\par\noindent Date: \today\vspace{-6pt}
\par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}

Modified: sandbox/committee/concepts/stdlib/clib-concepts.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-concepts.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-concepts.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -32,7 +32,8 @@
\begin{titlepage}
\begin{center}
\huge
-Core Concepts for the C++0x Standard Library
+Core Concepts for the C++0x Standard Library\\
+(Revision 1)
\vspace{0.25in}

\normalsize
@@ -44,7 +45,7 @@
\end{center}

\vspace{0.25in}
-\par\noindent Document number: DRAFT\vspace{-6pt}
+\par\noindent Document number: D2572=08-0082\vspace{-6pt}
\par\noindent Revises document number: N2502=08-0012\vspace{-6pt}
\par\noindent Date: \today\vspace{-6pt}
\par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}
@@ -95,7 +96,7 @@
 shaded box.}

\paragraph*{Changes from N2502}
-Closed concept issues 6, 12, and 14.
+Applied the proposed resolutions for concept issues 4, 6, 9, 10, 12, 14, and 17.

\end{titlepage}

@@ -173,8 +174,8 @@
 concept DerivedFrom<typename Derived, typename Base> { }

 // \ref{concept.comparison}, comparisons:
- auto concept LessThanComparable<typename T, typename U = T> @\textit{see below}@;
- auto concept EqualityComparable<typename T, typename U = T> @\textit{see below}@;
+ auto concept LessThanComparable<typename T> @\textit{see below}@;
+ auto concept EqualityComparable<typename T> @\textit{see below}@;
 auto concept TriviallyEqualityComparable<typename T> @\textit{see below}@;

 // \ref{concept.destruct}, destruction:
@@ -196,10 +197,6 @@
 auto concept Swappable<typename T> @\textit{see below}@;

 // \ref{concept.memory}, memory allocation:
- auto concept Newable<typename T, typename... Args> @\textit{see below}@;
- auto concept Deletable<typename T> @\textit{see below}@;
- auto concept ArrayNewable<typename T, typename... Args> @\textit{see below}@;
- auto concept ArrayDeletable<typename T> @\textit{see below}@;
 auto concept HeapAllocatable<typename T> @\textit{see below}@;

 // \ref{concept.regular}, regular types:
@@ -222,6 +219,8 @@
 auto concept HasModulus<typename T, typename U = T> @\textit{see below}@;
 auto concept HasUnaryPlus<typename T> @\textit{see below}@;
 auto concept HasNegate<typename T> @\textit{see below}@;
+ auto concept HasLess<typename T, typename U = T> @\textit{see below}@;
+ auto concept HasEquals<typename T, typename U = T> @\textit{see below}@;
 auto concept HasLogicalAnd<typename T, typename U = T> @\textit{see below}@;
 auto concept HasLogicalOr<typename T, typename U = T> @\textit{see below}@;
 auto concept HasLogicalNot<typename T> @\textit{see below}@;
@@ -267,7 +266,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} Describes types that can be used as the
+\addedConcepts{\mbox{\reallynote} Describes types that can be used as the
 return type of a function.}

\pnum
@@ -285,7 +284,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note}
+\addedConcepts{\mbox{\reallynote}
describes types to which a pointer can be
created.}

@@ -303,7 +302,7 @@

\begin{itemdescr}
\pnum
-\mbox{\note}
+\mbox{\reallynote}
describes types to which a reference or pointer-to-member can be
created.

@@ -321,7 +320,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that can be used to
+\addedConcepts{\mbox{\reallynote} describes types that can be used to
 declare a variable.}

\pnum
@@ -337,7 +336,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes object types ([basic.types]),
+\addedConcepts{\mbox{\reallynote} describes object types ([basic.types]),
 for which storage can be allocated.}

\pnum
@@ -354,7 +353,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes class types (i.e., unions,
+\addedConcepts{\mbox{\reallynote} describes class types (i.e., unions,
 classes, and structs).}

\pnum
@@ -369,7 +368,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes classes and structs ([class]).}
+\addedConcepts{\mbox{\reallynote} describes classes and structs ([class]).}

\pnum
\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -384,7 +383,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes union types ([class.union]).}
+\addedConcepts{\mbox{\reallynote} describes union types ([class.union]).}

\pnum
\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -398,7 +397,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes trivial types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes trivial types ([basic.types]).}

\pnum
\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -412,7 +411,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes standard-layout types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes standard-layout types ([basic.types]).}

\pnum
\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -427,7 +426,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes literal types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes literal types ([basic.types]).}

\pnum
\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -442,7 +441,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes scalar types ([basic.types]).}
+\addedConcepts{\mbox{\reallynote} describes scalar types ([basic.types]).}

\pnum
\addedConcepts{\mbox{\requires} for every type \mbox{\tcode{T}} that
@@ -456,7 +455,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describess type that can
+\addedConcepts{\mbox{\reallynote} describess type that can
be used as the type of a non-type template parameter ([temp.param]).}

\pnum
@@ -474,7 +473,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that
+\addedConcepts{\mbox{\reallynote} describes types that
can be the type of an integral constant expression ([expr.const]).}

\pnum
@@ -490,7 +489,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes integral types
+\addedConcepts{\mbox{\reallynote} describes integral types
([basic.fundamental]).}

\pnum
@@ -506,7 +505,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes enumeration types
+\addedConcepts{\mbox{\reallynote} describes enumeration types
([dcl.enum]).}

\pnum
@@ -522,7 +521,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes a same-type requirement
+\addedConcepts{\mbox{\reallynote} describes a same-type requirement
 ([temp.req]).}
\end{itemdescr}

@@ -543,17 +542,27 @@
\rSec2[concept.comparison]{Comparisons}

\begin{itemdecl}
-auto concept LessThanComparable<typename T, typename U = T> {
+auto concept HasLess<typename T, typename U = T> {
 bool operator<(T const& a, U const& b);
- bool operator>(U const& a, T const& b) { return b < a; }
- bool operator<=(U const& a, T const& b) { return !(b < a); }
- bool operator>=(T const& a, U const& b) { return !(a < b); }
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types whose values can be
+\addedConcepts{\mbox{\reallynote} describes types with an operator <.}
+\end{itemdescr}
+
+\begin{itemdecl}
+auto concept LessThanComparable<typename T> : HasLess<T> {
+ bool operator>(T const& a, T const& b) { return b < a; }
+ bool operator<=(T const& a, T const& b) { return !(b < a); }
+ bool operator>=(T const& a, T const& b) { return !(a < b); }
+}
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\addedConcepts{\mbox{\reallynote} describes types whose values can be
 ordered via an inequality operator.}

\pnum
@@ -570,7 +579,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types whose values can be
+\addedConcepts{\mbox{\reallynote} describes types whose values can be
compared for equality with \mbox{\tcode{operator==}}.}

\pnum
@@ -593,7 +602,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types whose equality comparison
+\addedConcepts{\mbox{\reallynote} describes types whose equality comparison
 operators (\mbox{\tcode{==}}, \mbox{\tcode{!=}}) can be implemented
 via a bitwise equality comparison, as with \mbox{\tcode{memcmp}}.
\mbox{\enternote} such types should not have
@@ -617,7 +626,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that can be destroyed,
+\addedConcepts{\mbox{\reallynote} describes types that can be destroyed,
 including scalar types, references, and class types with a public
 destructor.}

@@ -632,7 +641,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types whose
+\addedConcepts{\mbox{\reallynote} describes types whose
destructors do not need to be executed when the object is destroyed.}

\pnum
@@ -652,7 +661,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that can be constructed
+\addedConcepts{\mbox{\reallynote} describes types that can be constructed
 from a given set of arguments.}
\end{itemdescr}

@@ -662,26 +671,24 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that can be default-constructed.}
+\addedConcepts{\mbox{\reallynote} describes types that can be default-constructed.}
\end{itemdescr}

\rSec2[concept.copymove]{Copy and move}
\begin{itemdecl}
-auto concept MoveConstructible<typename T> : Destructible<T> {
- T::T(T&&);
-}
+auto concept MoveConstructible<typename T> : Constructible<T, T&&>, Destructible<T> { }
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note}
+\addedConcepts{\mbox{\reallynote}
describes types that can move-construct an
object from a value of the same type, possibly altering that
value.}
\end{itemdescr}

\begin{itemdecl}
-T::T(T&& rv);
+T::T(T&& rv); // note: inherited from Constructible<T, T\&\&>
\end{itemdecl}

\begin{itemdescr}
@@ -694,9 +701,8 @@
\end{itemdescr}

\begin{itemdecl}
-auto concept CopyConstructible<typename T> : MoveConstructible<T> {
- T::T(const T&);
-
+auto concept CopyConstructible<typename T> : MoveConstructible<T>, Constructible<T, const T&> {
+ @\addedCC{requires EqualityComparable<T>}@
 axiom CopyPreservation(T x) {
 T(x) == x;
 }
@@ -705,7 +711,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a public copy constructor.}
+\addedConcepts{\mbox{\reallynote} describes types with a public copy constructor.}
\end{itemdescr}

\begin{itemdecl}
@@ -714,7 +720,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types whose copy
+\addedConcepts{\mbox{\reallynote} describes types whose copy
constructor is equivalent to \mbox{\tcode{memcpy}}.}

\pnum
@@ -728,13 +734,13 @@
\begin{itemdecl}
auto concept MoveAssignable<typename T, typename U = T> {
 typename result_type;
- result_type @\addedCC{T::}@operator=(@\removedCC{T\&, }@U&&);
+ result_type T::operator=(U&&);
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with the ability
+\addedConcepts{\mbox{\reallynote} describes types with the ability
 to assign to an object from an rvalue, potentially altering the rvalue.}
\end{itemdescr}

@@ -757,6 +763,7 @@
 typename result_type;
 result_type T::operator=(const U&);

+ @\addedCC{requires EqualityComparable<T, U>}@
 axiom CopyPreservation(T& x, U y) {
 (x = y, x) == y;
 }
@@ -765,7 +772,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with the ability to assign to an
+\addedConcepts{\mbox{\reallynote} describes types with the ability to assign to an
object.}
\end{itemdescr}

@@ -782,7 +789,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types whose copy-assignment
+\addedConcepts{\mbox{\reallynote} describes types whose copy-assignment
 operator is equivalent to \mbox{\tcode{memcpy}}.}

\pnum
@@ -801,7 +808,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types for which two values of
+\addedConcepts{\mbox{\reallynote} describes types for which two values of
 that type can be swapped.}
\end{itemdescr}

@@ -818,61 +825,18 @@

\rSec2[concept.memory]{Memory allocation}
\begin{itemdecl}
-auto concept Newable<typename T, typename... Args> : ObjectType<T> {
- void* T::operator new(size_t size, Args...);
-}
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which objects can be
-allocated on the heap via \mbox{\tcode{new}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept Deletable<typename T> : ObjectType<T> {
+auto concept HeapAllocatable<typename T> {
+ void* T::operator new(size_t size);
+ void* T::operator new(size_t size, void*);
+ void* T::operator new[](size_t size);
 void T::operator delete(void*);
-}
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which objects on the
-heap can be freed with \mbox{\tcode{delete}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept ArrayNewable<typename T, typename... Args> : ObjectType<T> {
- void* T::operator new[](size_t size, Args...);
-}
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which arrays of
-objects can be allocated on the heap via array \mbox{\tcode{new}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept ArrayDeletable<typename T> : ObjectType<T> {
 void T::operator delete[](void*);
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types for which an array
-objects on the heap can be freed with \mbox{\tcode{delete[]}}.}
-\end{itemdescr}
-
-\begin{itemdecl}
-auto concept HeapAllocatable<typename T>
- : Newable<T>, Deletable<T>, ArrayNewable<T>, ArrayDeletable<T> { }
-\end{itemdecl}
-
-\begin{itemdescr}
-\pnum
-\addedConcepts{\mbox{\note} describes types for which objects and
+\addedConcepts{\mbox{\reallynote} describes types for which objects and
arrays of objects can be allocated on or freed from the heap with
\mbox{\tcode{new}} and \mbox{\tcode{delete}}.}
\end{itemdescr}
@@ -880,25 +844,25 @@
\rSec2[concept.regular]{Regular types}

\begin{itemdecl}
-auto concept Semiregular<typename T> : CopyConstructible<T>, CopyAssignable<T> {
+auto concept Semiregular<typename T> : CopyConstructible<T>, CopyAssignable<T>, HeapAllocatable<T> {
 requires SameType<CopyAssignable<T>::result_type, T&>;
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} collects several common
+\addedConcepts{\mbox{\reallynote} collects several common
requirements supported by most types.}
\end{itemdescr}

\begin{itemdecl}
auto concept Regular<typename T>
- : Semiregular<T>, DefaultConstructible<T>, EqualityComparable<T>, HeapAllocatable<T> { }
+ : Semiregular<T>, DefaultConstructible<T>, EqualityComparable<T> { }
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes semi-regular types that are default
+\addedConcepts{\mbox{\reallynote} describes semi-regular types that are default
constructible, have equality comparison operators, and can be
allocated on the heap.}
\end{itemdescr}
@@ -913,7 +877,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a conversion (explicit
+\addedConcepts{\mbox{\reallynote} describes types with a conversion (explicit
or implicit) from one type to another.}
\end{itemdescr}

@@ -925,7 +889,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an implicit conversion from one
+\addedConcepts{\mbox{\reallynote} describes types with an implicit conversion from one
type to another.}
\end{itemdescr}

@@ -938,7 +902,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} used to express the requirement that a
+\addedConcepts{\mbox{\reallynote} used to express the requirement that a
 particular integral constant expression evaluate true.}

\pnum
@@ -951,199 +915,165 @@
auto concept HasPlus<typename T, typename U = T> {
 typename result_type;
 result_type operator+(T const&, U const&);
- @\removedCC{result_type operator+(T const\&, U \&\&);}@
- @\removedCC{result_type operator+(T \&\&, U const\&);}@
- @\removedCC{result_type operator+(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a binary \mbox{\tcode{operator+}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator+}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasMinus<typename T, typename U = T> {
 typename result_type;
 result_type operator-(T const&, U const&);
- @\removedCC{result_type operator-(T const\&, U \&\&);}@
- @\removedCC{result_type operator-(T \&\&, U const\&);}@
- @\removedCC{result_type operator-(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a binary \mbox{\tcode{operator-}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator-}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasMultiply<typename T, typename U = T> {
 typename result_type;
 result_type operator*(T const&, U const&);
- @\removedCC{result_type operator*(T const\&, U \&\&);}@
- @\removedCC{result_type operator*(T \&\&, U const\&);}@
- @\removedCC{result_type operator*(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with} \changedCC{an}{a binary} \addedConcepts{\mbox{\tcode{operator*}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator*}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasDivide<typename T, typename U = T> {
 typename result_type;
 result_type operator/(T const&, U const&);
- @\removedCC{result_type operator/(T const\&, U \&\&);}@
- @\removedCC{result_type operator/(T \&\&, U const\&);}@
- @\removedCC{result_type operator/(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator/}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator/}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasModulus<typename T, typename U = T> {
 typename result_type;
 result_type operator%(T const&, U const&);
- @\removedCC{result_type operator\%(T const\&, U \&\&);}@
- @\removedCC{result_type operator\%(T \&\&, U const\&);}@
- @\removedCC{result_type operator\%(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator\%}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator\%}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasUnaryPlus<typename T> {
 typename result_type;
 result_type operator+(T const&);
- @\removedCC{result_type operator+(T \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\mbox{\note} describes types with a unary \mbox{\tcode{operator+}}.
+\mbox{\reallynote} describes types with a unary \mbox{\tcode{operator+}}.
\end{itemdescr}

\begin{itemdecl}
auto concept HasNegate<typename T> {
 typename result_type;
 result_type operator-(T const&);
- @\removedCC{result_type operator-(T \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a unary \mbox{\tcode{operator-}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a unary \mbox{\tcode{operator-}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasLogicalAnd<typename T, typename U = T> {
 bool operator&&(T const&, U const&);
- @\removedCC{bool operator\&\&(T const\&, U \&\&);}@
- @\removedCC{bool operator\&\&(T \&\&, U const\&);}@
- @\removedCC{bool operator\&\&(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a logical conjunction operator.}
+\addedConcepts{\mbox{\reallynote} describes types with a logical conjunction operator.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasLogicalOr<typename T, typename U = T> {
 bool operator||(T const&, U const&);
- @\removedCC{bool operator||(T const\&, U \&\&);}@
- @\removedCC{bool operator||(T \&\&, U const\&);}@
- @\removedCC{bool operator||(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a logical disjunction operator.}
+\addedConcepts{\mbox{\reallynote} describes types with a logical disjunction operator.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasLogicalNot<typename T> {
 bool operator!(T const&);
- @\removedCC{bool operator!(T \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a logical negation operator.}
+\addedConcepts{\mbox{\reallynote} describes types with a logical negation operator.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasBitAnd<typename T, typename U = T> {
 typename result_type;
 result_type operator&(T const&, U const&);
- @\removedCC{result_type operator\&(T const\&, U \&\&);}@
- @\removedCC{result_type operator\&(T \&\&, U const\&);}@
- @\removedCC{result_type operator\&(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a binary \mbox{\tcode{operator\&}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a binary \mbox{\tcode{operator\&}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasBitOr<typename T, typename U = T> {
 typename result_type;
 result_type operator|(T const&, U const&);
- @\removedCC{result_type operator|(T const\&, U \&\&);}@
- @\removedCC{result_type operator|(T \&\&, U const\&);}@
- @\removedCC{result_type operator|(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator|}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator|}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasBitXor<typename T, typename U = T> {
 typename result_type;
 result_type operator^(T const&, U const&);
- @\removedCC{result_type operator\^(T const\&, U \&\&);}@
- @\removedCC{result_type operator\^(T \&\&, U const\&);}@
- @\removedCC{result_type operator\^(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an \mbox{\tcode{operator\^}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an \mbox{\tcode{operator\^}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept HasComplement<typename T> {
 typename result_type;
 result_type operator~(T const&);
- @\removedCC{result_type operator$\sim{}$(T \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an
+\addedConcepts{\mbox{\reallynote} describes types with an
 \mbox{\tcode{operator\~}}.}
\end{itemdescr}

@@ -1151,30 +1081,24 @@
auto concept HasLeftShift<typename T, typename U = T> {
 typename result_type;
 result_type operator<<(T const&, U const&);
- @\removedCC{result_type operator$\langle\langle$(T const\&, U \&\&);}@
- @\removedCC{result_type operator$\langle\langle$(T \&\&, U const\&);}@
- @\removedCC{result_type operator$\langle\langle$(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\mbox{\note} describes types with an \mbox{\tcode{operator$<<$}}.
+\mbox{\reallynote} describes types with an \mbox{\tcode{operator$<<$}}.
\end{itemdescr}

\begin{itemdecl}
auto concept HasRightShift<typename T, typename U = T> {
 typename result_type;
 result_type operator>>(T const&, U const&);
- @\removedCC{result_type operator$\rangle\rangle$(T const\&, U \&\&);}@
- @\removedCC{result_type operator$\rangle\rangle$(T \&\&, U const\&);}@
- @\removedCC{result_type operator$\rangle\rangle$(T \&\&, U \&\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\mbox{\note} describes types with an \mbox{\tcode{operator$>>$}}.
+\mbox{\reallynote} describes types with an \mbox{\tcode{operator$>>$}}.
\end{itemdescr}

\begin{itemdecl}
@@ -1186,21 +1110,19 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with a dereferencing \mbox{\tcode{operator*}}.}
+\addedConcepts{\mbox{\reallynote} describes types with a dereferencing \mbox{\tcode{operator*}}.}
\end{itemdescr}

\begin{itemdecl}
auto concept Addressable<typename T> {
 typename pointer;
- @\removedCC{typename const_pointer;}@
 pointer operator&(T&);
- @\removedCC{const_pointer operator\&(const T\&);}@
}
\end{itemdecl}

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types with an address-of \mbox{\tcode{operator\&}}.}
+\addedConcepts{\mbox{\reallynote} describes types with an address-of \mbox{\tcode{operator\&}}.}
\end{itemdescr}

\begin{itemdecl}
@@ -1212,7 +1134,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes function object types
+\addedConcepts{\mbox{\reallynote} describes function object types
callable given arguments of types \mbox{\tcode{Args...}}.}
\end{itemdescr}

@@ -1245,7 +1167,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the
 operations available on arithmetic types ([basic.fundamental]).}
\end{itemdescr}

@@ -1272,7 +1194,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the operations
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the operations
 available on integral types.}
\end{itemdescr}

@@ -1282,7 +1204,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the
 operations available on signed integral types.}

\pnum
@@ -1299,7 +1221,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes types that provide all of the
+\addedConcepts{\mbox{\reallynote} describes types that provide all of the
 operations available on unsigned integral types.}

\pnum
@@ -1316,7 +1238,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes floating-point types.}
+\addedConcepts{\mbox{\reallynote} describes floating-point types.}

\pnum
\addedConcepts{\mbox{\requires}
@@ -1335,7 +1257,7 @@

\begin{itemdescr}
\pnum
-\addedConcepts{\mbox{\note} describes function objects
+\addedConcepts{\mbox{\reallynote} describes function objects
callable with some set of arguments, the result of which can be used in a
context that requires a \mbox{\tcode{bool}}.}

@@ -1388,14 +1310,12 @@
 template<ObjectType T> class rebind = @\textit{see below}@;

 requires Convertible<pointer, const_pointer> &&
- Convertible<pointer, void*> &&
 Convertible<pointer, value_type*> &&
 SameType<pointer::value_type, value_type> &&
 SameType<pointer::reference, value_type&> &&
 SameType<pointer::reference, reference>;

- requires Convertible<const_pointer, const void*> &&
- @\textcolor{addclr}{Convertible}@<const_pointer, const value_type&> &&
+ requires @\textcolor{addclr}{Convertible}@<const_pointer, const value_type*> &&
 SameType<const_pointer::value_type, value_type> &&
 SameType<const_pointer::reference, const value_type&> &&
 SameType<const_pointer::reference, const_reference>;
@@ -1556,7 +1476,7 @@
\color{addclr}
\begin{itemdecl}
template<typename V>
- requires Constructible<value_type, V&&>
+ requires Constructible<value_type, V>
 void X::construct(pointer p, V&&);
\end{itemdecl}
\color{black}

Modified: sandbox/committee/concepts/stdlib/clib-iterators.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-iterators.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-iterators.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -30,8 +30,8 @@
\begin{titlepage}
\begin{center}
\huge
-Iterator Concepts for the C++0x Standard Library
-
+Iterator Concepts for the C++0x Standard Library\\
+(Revision 1)
\vspace{0.5in}

\normalsize
@@ -40,8 +40,8 @@
\end{center}

\vspace{1in}
-\par\noindent Document number: N2500=08-0010 \vspace{-6pt}
-\par\noindent Revises document number: N2323=07-0183 \vspace{-6pt}
+\par\noindent Document number: D2570=08-0080 \vspace{-6pt}
+\par\noindent Revises document number: N2500=08-0010 \vspace{-6pt}
\par\noindent Date: \today\vspace{-6pt}
\par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}
\par\noindent Reply-to: Douglas Gregor $<$\href{mailto:dgregor_at_[hidden]}{dgregor_at_[hidden]}$>$\vspace{-6pt}

Modified: sandbox/committee/concepts/stdlib/clib-numerics.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-numerics.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-numerics.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -44,7 +44,7 @@
\end{center}

\vspace{1in}
-\par\noindent Document number: DRAFT\vspace{-6pt}
+\par\noindent Document number: D2574=08-0084\vspace{-6pt}
\par\noindent Revises document number: N2041=06-0111\vspace{-6pt}
\par\noindent Date: \today\vspace{-6pt}
\par\noindent Project: Programming Language \Cpp{}, Library Working Group\vspace{-6pt}

Modified: sandbox/committee/concepts/stdlib/macros.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/macros.tex (original)
+++ sandbox/committee/concepts/stdlib/macros.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -168,6 +168,8 @@
\newcommand{\complexity}{\Fundesc{Complexity}}
\newcommand{\note}{\Fundesc{Remark}}
\newcommand{\notes}{\Fundesc{Remarks}}
+\newcommand{\reallynote}{\Fundesc{Note}}
+\newcommand{\reallynotes}{\Fundesc{Notes}}
\newcommand{\implimits}{\Fundesc{Implementation limits}}
\newcommand{\replaceable}{\Fundesc{Replaceable}}
\newcommand{\exceptionsafety}{\Fundesc{Exception safety}}

Modified: sandbox/committee/concepts/wording/wording.tex
==============================================================================
--- sandbox/committee/concepts/wording/wording.tex (original)
+++ sandbox/committee/concepts/wording/wording.tex 2008-03-11 14:46:38 EDT (Tue, 11 Mar 2008)
@@ -44,7 +44,7 @@
Jeremy Siek, University of Colorado at Boulder \\
James Widman, Gimpel Software
\end{tabular}\vspace{-6pt}
-\par\noindent Document number: DRAFT \vspace{-6pt}
+\par\noindent Document number: D2571=08-0081 \vspace{-6pt}
\par\noindent Revises document number: N2501=08-0011 \vspace{-6pt}
\par\noindent Date: \today\vspace{-6pt}
\par\noindent Project: Programming Language C++, Core Working Group\vspace{-6pt}

Next message: stipe_at_[hidden]: "[Boost-commit] svn:boost r43568 - sandbox/SOC/2007/signals/libs/dataflow/test/utility"
Previous message: kbelco_at_[hidden]: "[Boost-commit] svn:boost r43566 - trunk/tools/build/v2/tools"

Date view	Thread view	Subject view	Author view

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