[Boost-commit] svn:boost r45405 - sandbox/committee/concepts/stdlib

From: dgregor_at_[hidden]
Date: 2008-05-15 16:45:49

Author: dgregor
Date: 2008-05-15 16:45:49 EDT (Thu, 15 May 2008)
New Revision: 45405
URL: http://svn.boost.org/trac/boost/changeset/45405

Log:
Address some comments from Daniel Kruegler
Text files modified: 
   sandbox/committee/concepts/stdlib/clib-iterators.tex |    54 ++++++++++++++++++++--------------------
   1 files changed, 27 insertions(+), 27 deletions(-)

Modified: sandbox/committee/concepts/stdlib/clib-iterators.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-iterators.tex	(original)
+++ sandbox/committee/concepts/stdlib/clib-iterators.tex	2008-05-15 16:45:49 EDT (Thu, 15 May 2008)
@@ -63,9 +63,9 @@
 \editorial{Purely editorial comments will be written in a separate,
   shaded box.}
 
-\paragraph*{Changes from N2500}
+\paragraph*{Changes from N2570}
 \begin{itemize}
-\item Applied the proposed resolutions for concept issues 19, 22, and 25.
+\item The \tcode{value_type} of an iterator is an \tcode{ObjectType}.
 \end{itemize}
 
 \end{titlepage}
@@ -128,8 +128,8 @@
   concept OutputIterator<typename X, typename Value> @\textit{see below}@;
   concept BasicOutputIterator<typename X> @\textit{see below}@;
 
-  template<BasicOutputIterator X, typename Value>
-    requires CopyAssignable<X::reference, Value>
+  template<BasicOutputIterator X, @\changedCC{typename}{CopyAssignable}@ Value>
+    requires HasCopyAssign<X::reference, Value>
     concept_map OutputIterator<X, Value> @\textit{see below}@;
 
   // \ref{forward.iterators}, forward iterators:
@@ -386,14 +386,14 @@
 \color{addclr}
 \begin{codeblock}
 concept InputIterator<typename X> : Semiregular<X>, EqualityComparable<X> {
-  typename value_type = typename X::value_type;
+  @\changedCC{typename}{ObjectType}@ value_type = typename X::value_type;
   MoveConstructible reference = typename X::reference; 
   MoveConstructible pointer = typename X::pointer;
 
   SignedIntegral@\addedCC{Like}@ difference_type = typename X::difference_type;
 
-  requires @\addedCC{IntegerType<difference_type>}@
-        && Convertible<reference, value_type>;
+  requires @\addedCC{IntegralType<difference_type>}@
+        && Convertible<reference, value_type @\addedCC{const \&}@>;
         @\textcolor{addclr}{}@&& Convertible<pointer, const value_type*>;
 
   MoveConstructible postincrement_result;
@@ -559,12 +559,12 @@
 \begin{itemdecl}
 concept OutputIterator<typename X, typename Value> : CopyConstructible<X> {
   typename reference;
-  requires CopyAssignable<reference, Value>;
+  requires HasCopyAssign<reference, Value> \@addedCC{\&\& CopyAssignable<Value>}@;
 
   typename postincrement_result;
-  requires Dereferenceable<postincrement_result&> &&
+  requires Dereferenceable<postincrement_result> &&
            Convertible<postincrement_result, const X&> &&
-           CopyAssignable<Dereferenceable<postincrement_result&>::reference, Value>;
+           HasCopyAssign<Dereferenceable<postincrement_result>::reference, Value>;
 
   reference operator*(X&);
   X& operator++(X&);
@@ -604,14 +604,14 @@
 \color{addclr}
 \begin{itemdecl}
 concept BasicOutputIterator<typename X> : CopyConstructible<X> {
-  typename value_type = typename X::value_type;
+  @\changedCC{typename}{ObjectType}@ value_type = typename X::value_type;
   MoveConstructible reference = typename X::reference; 
 
-  requires CopyAssignable<reference, value_type>;
+  requires HasCopyAssign<reference, value_type> @\addedCC{\&\& CopyAssignable<value_type>}@;
 
   typename postincrement_result;
-  requires Dereferenceable<postincrement_result&>,
-           CopyAssignable<Dereferenceable<postincrement_result&>::reference, value_type>,
+  requires Dereferenceable<postincrement_result> &&
+           HasCopyAssign<Dereferenceable<postincrement_result>::reference, value_type> &&
            Convertible<postincrement_result, const X&>;
 
   @\textcolor{addclr}{}@reference operator*(X&);
@@ -645,7 +645,7 @@
 
 \pnum
 Every \tcode{BasicOutputIterator} is an \tcode{OutputIterator} for
-value types \tcode{CopyAssignable} to its
+value types copy-assignable to its
 \tcode{reference} type. \footnote{This allows algorithms specified with
   \tcode{OutputIterator} (the less restrictive concept) to work with
   iterators that have concept maps for the more common
@@ -654,7 +654,7 @@
 
 \color{addclr}
 \begin{itemdecl}
-template<BasicOutputIterator X, typename Value>
+template<BasicOutputIterator X, @\changedCC{typename}{CopyAssignable}@ Value>
 requires CopyAssignable<X::reference, Value>
 concept_map OutputIterator<X, Value> {
   typedef X::reference                reference;
@@ -718,13 +718,13 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedCC{reference operator*(X\&);}@
-@\addedCC{reference operator*(X const\&);}@
+@\removedCC{reference operator*(X\&);}@
+@\removedCC{reference operator*(X const\&);}@
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\addedCC{\mbox{\requires} If two iterators \mbox{\tcode{a}} and
+\removedCC{\mbox{\requires} If two iterators \mbox{\tcode{a}} and
   \mbox{\tcode{b}} of the same type are both dereferenceable, then
   \mbox{\tcode{a == b}} if and only if \mbox{\tcode{*a}} and
   \mbox{\tcode{*b}} are the same object.}
@@ -847,7 +847,7 @@
 
 \color{addclr}
 \begin{itemdecl}
-X& operator+=(X&, difference_type);
+X& operator+=(X& r, difference_type m);
 \end{itemdecl}
 
 \pnum
@@ -886,7 +886,7 @@
 \tcode{r += -n}
 
 \begin{itemdecl}
-X operator-(X @\addedCC{const\&}@, difference_type);
+X operator-(X @\addedCC{const\&}@ a, difference_type n);
 \end{itemdecl}
 
 \pnum
@@ -1084,9 +1084,9 @@
 };
 
 template<BasicOutputIterator Iterator> struct iterator_traits<Iterator> {
-  typedef Iterator::difference_type            difference_type;
+  typedef void                                 difference_type;
   typedef Iterator::value_type                 value_type;
-  typedef Iterator::pointer                    pointer;
+  typedef void                                 pointer;
   typedef Iterator::reference                  reference;
   typedef output_iterator_tag                  iterator_category;
 };
@@ -1244,7 +1244,7 @@
 for any type \tcode{Iterator} with
 \\\tcode{iterator_traits<Iterator>::it\-er\-a\-tor_ca\-te\-go\-ry} convertible to
 \tcode{forward_iterator_tag} for which the \tcode{reference} type is
-\tcode{CopyAssignable} from the \tcode{value_type}.
+copy-assignable from the \tcode{value_type}.
 
 \textcolor{addclr}{\pnum}
 The library shall provide a concept map
@@ -1259,7 +1259,7 @@
 for any type \tcode{Iterator} with
 \\\tcode{iterator_traits<Iterator>::it\-er\-a\-tor_ca\-te\-go\-ry} convertible to
 \tcode{bidirectional_iterator_tag} for which the \tcode{reference}
-type is \tcode{CopyAssignable} from the \tcode{value_type}.
+type is copy-assignable from the \tcode{value_type}.
 
 \pnum
 The library shall provide a concept map
@@ -1274,12 +1274,12 @@
 for any type \tcode{Iterator} with
 \\\tcode{iterator_traits<Iterator>::it\-er\-a\-tor_ca\-te\-go\-ry} convertible to
 \tcode{random_access_iterator_tag} for which the \tcode{reference} type is
-\tcode{CopyAssignable} from the \tcode{value_type}.
+copy-assignable from the \tcode{value_type}.
 \color{black}
 
 \section*{Acknowledgments}
 Thanks to Beman Dawes for alerting us to omissions from the iterator
-concepts. 
+concepts and Daniel Kr\"ugler for additional many helpful comments.
 
 \bibliographystyle{plain}
 \bibliography{../local}