Boost logo

Boost-Commit :

From: dgregor_at_[hidden]
Date: 2008-06-30 01:09:16


Author: dgregor
Date: 2008-06-30 01:09:15 EDT (Mon, 30 Jun 2008)
New Revision: 46885
URL: http://svn.boost.org/trac/boost/changeset/46885

Log:
Okay, we're going to call them Shuffle iterators
Text files modified:
   sandbox/committee/concepts/stdlib/clib-algorithms.tex | 78 ++++++++++++++++++++--------------------
   sandbox/committee/concepts/stdlib/clib-containers.tex | 4 +-
   sandbox/committee/concepts/stdlib/clib-iterators.tex | 32 ++++++++--------
   3 files changed, 57 insertions(+), 57 deletions(-)

Modified: sandbox/committee/concepts/stdlib/clib-algorithms.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-algorithms.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-algorithms.tex 2008-06-30 01:09:15 EDT (Mon, 30 Jun 2008)
@@ -90,7 +90,7 @@
   \tcode{includes}, \tcode{set_union}, \tcode{set_intersection},
   \tcode{set_difference}, and \tcode{set_symmetric_difference}, to
   match C++03 requirements.
-\item Introduce the use of the \tcode{MovableIterator} concept, for
+\item Introduce the use of the \tcode{ShuffleIterator} concept, for
   algorithms that require the ability to move elements between the
   sequence and a variable of the iterator \tcode{value_type} (e.g.,
   \tcode{sort}).
@@ -450,43 +450,43 @@
           @\addedCC{\&\& CopyConstructible<Pred>}@
     Iter partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
   template<BidirectionalIterator Iter, Predicate<auto@\addedCC{,}@ Iter::@\changedCCC{reference}{value_type}@> Pred>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Pred>}@
     Iter stable_partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
 
   @\textcolor{black}{// \ref{alg.sorting}, sorting and related operations:}@
   @\textcolor{black}{// \ref{alg.sort}, sorting:}@
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void sort(Iter @\farg{first}@, Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
             @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void sort(Iter @\farg{first}@, Iter @\farg{last}@,
               Compare @\farg{comp}@);
 
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@,
                      Compare @\farg{comp}@);
 
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void partial_sort(Iter @\farg{first}@,
                       Iter @\farg{middle}@,
                       Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void partial_sort(Iter @\farg{first}@,
                       Iter @\farg{middle}@,
@@ -528,7 +528,7 @@
                          Compare @\farg{comp}@);
 
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
                      Iter @\farg{last}@);
@@ -536,7 +536,7 @@
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
     requires @\removedCCC{SameType<Iter::value_type\&, Iter::reference> \&\& Swappable<Iter::value_type> \&\&}@
              @\removedCCC{MoveConstructible<Iter::value_type> \&\& MoveAssignable<Iter::value_type>}@
- @\addedCC{MovableIterator<Iter>}@
+ @\addedCC{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
                      Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -611,14 +611,14 @@
                   OutIter @\farg{result}@, Compare @\farg{comp}@);
 
   template<BidirectionalIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void inplace_merge(Iter @\farg{first}@,
                        Iter @\farg{middle}@,
                        Iter @\farg{last}@);
   template<BidirectionalIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void inplace_merge(Iter @\farg{first}@,
                        Iter @\farg{middle}@,
@@ -754,45 +754,45 @@
 
   @\textcolor{black}{// \ref{alg.heap.operations}, heap operations:}@
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void push_heap(Iter @\farg{first}@, Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void push_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                    Compare @\farg{comp}@);
 
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                   Compare @\farg{comp}@);
 
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void make_heap(Iter @\farg{first}@, Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void make_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                    Compare @\farg{comp}@);
 
   template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           && LessThanComparable<Iter::value_type>
     void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@);
   template<RandomAccessIterator Iter,
            @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
           @\addedCC{\&\& CopyConstructible<Compare>}@
     void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                    Compare @\farg{comp}@);
@@ -2556,7 +2556,7 @@
 \index{stable_partition@\tcode{stable_partition}}%
 \color{addclr}\begin{itemdecl}
 template<BidirectionalIterator Iter, Predicate<auto@\addedCC{,}@ Iter::@\changedCCC{reference}{value_type}@> Pred>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Pred>}@
   Iter stable_partition(Iter @\farg{first}@, Iter @\farg{last}@, Pred @\farg{pred}@);
 \end{itemdecl}\color{black}
@@ -2613,13 +2613,13 @@
 \index{sort@\tcode{sort}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         && LessThanComparable<Iter::value_type>
   void sort(Iter @\farg{first}@, Iter @\farg{last}@);
 
 template<RandomAccessIterator Iter,
           @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void sort(Iter @\farg{first}@, Iter @\farg{last}@,
             Compare @\farg{comp}@);
@@ -2658,13 +2658,13 @@
 \index{stable_sort@\tcode{stable_sort}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         && LessThanComparable<Iter::value_type>
   void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@);
 
 template<RandomAccessIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void stable_sort(Iter @\farg{first}@, Iter @\farg{last}@,
                    Compare @\farg{comp}@);
@@ -2702,14 +2702,14 @@
 \index{partial_sort@\tcode{partial_sort}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         && LessThanComparable<Iter::value_type>
   void partial_sort(Iter @\farg{first}@,
                     Iter @\farg{middle}@,
                     Iter @\farg{last}@);
 template<RandomAccessIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void partial_sort(Iter @\farg{first}@,
                     Iter @\farg{middle}@,
@@ -2863,7 +2863,7 @@
 \index{nth_element@\tcode{nth_element}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         && LessThanComparable<Iter::value_type>
   void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
                    Iter @\farg{last}@);
@@ -2872,7 +2872,7 @@
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
   requires @\removedCCC{SameType<Iter::value_type\&, Iter::reference> \&\& Swappable<Iter::value_type> \&\&}@
            @\removedCCC{MoveConstructible<Iter::value_type> \&\& MoveAssignable<Iter::value_type>}@
- @\addedCC{MovableIterator<Iter>}@
+ @\addedCC{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void nth_element(Iter @\farg{first}@, Iter @\farg{nth}@,
                    Iter @\farg{last}@, Compare @\farg{comp}@);
@@ -3228,7 +3228,7 @@
 \index{inplace_merge@\tcode{inplace_merge}}%
 \color{addclr}\begin{itemdecl}
 template<BidirectionalIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         && LessThanComparable<Iter::value_type>
   void inplace_merge(Iter @\farg{first}@,
                      Iter @\farg{middle}@,
@@ -3236,7 +3236,7 @@
 
 template<BidirectionalIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void inplace_merge(Iter @\farg{first}@,
                      Iter @\farg{middle}@,
@@ -3653,13 +3653,13 @@
 \index{push_heap@\tcode{push_heap}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         && LessThanComparable<Iter::value_type>
   void push_heap(Iter @\farg{first}@, Iter @\farg{last}@);
 
 template<RandomAccessIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void push_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                  Compare @\farg{comp}@);
@@ -3696,12 +3696,12 @@
 \index{pop_heap@\tcode{pop_heap}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@ && LessThanComparable<Iter::value_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@ && LessThanComparable<Iter::value_type>
   void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@);
 
 template<RandomAccessIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void pop_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                 Compare @\farg{comp}@);
@@ -3742,13 +3742,13 @@
 \index{make_heap@\tcode{make_heap}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@ &&
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@ &&
            LessThanComparable<Iter::value_type>
   void make_heap(Iter @\farg{first}@, Iter @\farg{last}@);
 
 template<RandomAccessIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void make_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                  Compare @\farg{comp}@);
@@ -3779,12 +3779,12 @@
 \index{sort_heap@\tcode{sort_heap}}%
 \color{addclr}\begin{itemdecl}
 template<RandomAccessIterator Iter>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@ && LessThanComparable<Iter::value_type>
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@ && LessThanComparable<Iter::value_type>
   void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@);
 
 template<RandomAccessIterator Iter,
          @\changedCCC{Predicate}{StrictWeakOrder}@<auto, Iter::value_type@\removedCCC{, Iter::value_type}@> Compare>
- requires @\changedCCC{SwappableIterator<Iter>}{MovableIterator<Iter>}@
+ requires @\changedCCC{SwappableIterator<Iter>}{ShuffleIterator<Iter>}@
         @\addedCC{\&\& CopyConstructible<Compare>}@
   void sort_heap(Iter @\farg{first}@, Iter @\farg{last}@,
                  Compare @\farg{comp}@);

Modified: sandbox/committee/concepts/stdlib/clib-containers.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-containers.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-containers.tex 2008-06-30 01:09:15 EDT (Mon, 30 Jun 2008)
@@ -1260,7 +1260,7 @@
   template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{BackInsertionSequence}@ Cont@\removedConcepts{ainer}@ = vector<T>,
         @\changedConcepts{class}{Predicate<auto, T, T>}@ Compare = less<typename Cont@\removedConcepts{ainer}@::value_type> >
     @\addedConcepts{requires SameType<Cont::value_type, T> \&\&} \removedCCC{Mutable}\addedConcepts{RandomAccessIterator<Cont::iterator>}@
- @\addedConcepts{\&\& }\changedCCC{Swappable}{Movable}\addedConcepts{Iterator<Cont::iterator> \&\& CopyConstructible<Compare>}@
+ @\addedConcepts{\&\& }\changedCCC{Swappable}{Shuffle}\addedConcepts{Iterator<Cont::iterator> \&\& CopyConstructible<Compare>}@
              @\addedCC{Swappable<Cont>}@
   class priority_queue;
   template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
@@ -3517,7 +3517,7 @@
   template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{BackInsertionSequence}@ Cont@\removedConcepts{ainer}@ = vector<T>,
        @\changedConcepts{class}{Predicate<auto, T, T>}@ Compare = less<typename Cont@\removedConcepts{ainer}@::value_type> >
   @\addedConcepts{requires SameType<Cont::value_type, T> \&\&} \removedCCC{Mutable}\addedConcepts{RandomAccessIterator<Cont::iterator>}@
- @\addedConcepts{\&\&} \changedCCC{Swappable}{Movable}\addedConcepts{Iterator<Cont::iterator> \&\& CopyConstructible<Compare>}@@\addedCC{ \&\& HasSize<Cont> \&\& Swappable<Cont>}@
+ @\addedConcepts{\&\&} \changedCCC{Swappable}{Shuffle}\addedConcepts{Iterator<Cont::iterator> \&\& CopyConstructible<Compare>}@@\addedCC{ \&\& HasSize<Cont> \&\& Swappable<Cont>}@
   class priority_queue {
   public:
     typedef typename Cont@\removedConcepts{ainer}@::value_type value_type;

Modified: sandbox/committee/concepts/stdlib/clib-iterators.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-iterators.tex (original)
+++ sandbox/committee/concepts/stdlib/clib-iterators.tex 2008-06-30 01:09:15 EDT (Mon, 30 Jun 2008)
@@ -125,7 +125,7 @@
 reference type of the iterator (which may be an lvalue reference,
 rvalue reference, or a proxy class). The new iterator taxonomy
 captures these forms of mutability through two iterator concepts:
-\tcode{OutputIterator} and \tcode{MovableIterator}.
+\tcode{OutputIterator} and \tcode{ShuffleIterator}.
 
 The \tcode{OutputIterator} concept (\ref{output.iterators}) is a
 faithful representation of a C++98/03 output iterator. Output
@@ -222,10 +222,10 @@
 moving through a sequence of values---but does not provide any read or
 write capabilities.
 
-The \tcode{MovableIterator} concept (\ref{movable.iterators}) is a new
+The \tcode{ShuffleIterator} concept (\ref{shuffle.iterators}) is a new
 kind of iterator that captures the requirements needed to shuffle
 values within a sequence using moves and
-swaps. \tcode{MovableIterator} allows one to
+swaps. \tcode{ShuffleIterator} allows one to
 move-construct or move-assign from an element in the sequence into a
 variable of the iterator's value type. This permits, for example, the
 pivot element in a quicksort to be extracted from the sequence and
@@ -235,7 +235,7 @@
 concept is the proxy-aware conceptualization of the
 Swappable+MoveConstructible+MoveAssignable set of concepts from the
 reflector discussion starting with c++std-lib-21212. The
-\tcode{MovableIterator} concept is used sparingly, in those cases
+\tcode{ShuffleIterator} concept is used sparingly, in those cases
 where the sequence cannot be efficiently reordered within simple swap
 operations.
 
@@ -262,7 +262,7 @@
   no longer needed as a base for the mutable iterator concepts.
 \item Removed the \tcode{SwappableIterator} concept, which is no
   longer used in algorithms. Instead, we use \tcode{HasSwap} or the
- new \tcode{MovableIterator} concept.
+ new \tcode{ShuffleIterator} concept.
 \end{itemize}
 
 
@@ -391,8 +391,8 @@
   @\removedCCC{// \mbox{\ref{swappable.iterators}}, swappable iterators:}@
   @\removedCCC{concept SwappableIterator<typename X> \mbox{\textit{see below}};}@
 
- @\addedCC{// \mbox{\ref{movable.iterators}}, movable iterators:}@
- @\addedCC{auto concept MovableIterator<typename X> \mbox{\textit{see below}};}@
+ @\addedCC{// \mbox{\ref{shuffle.iterators}}, shuffle iterators:}@
+ @\addedCC{auto concept ShuffleIterator<typename X> \mbox{\textit{see below}};}@
 }
 \end{codeblock}
 \color{black}
@@ -453,7 +453,7 @@
 \techterm{forward iterators},
 \techterm{bidirectional iterators},
 \techterm{random access iterators}, and
-\addedCC{movable iterators},
+\addedCC{shuffle iterators},
 as shown in Table~\ref{tab:iterators.relations}.
 
 \begin{floattable}{Relations among iterator \changedConcepts{categories}{concepts}}{tab:iterators.relations}
@@ -462,7 +462,7 @@
 \textbf{Random Access} & $\rightarrow$ \textbf{Bidirectional} &
 $\rightarrow$ \textbf{Forward} & $\rightarrow$ \textbf{Input} & \addedCC{\mbox{$\rightarrow$} \mbox{\textbf{Iterator}}} \\
  & & & \addedCC{\mbox{$\uparrow$}} & \addedCC{\mbox{$\uparrow$}} \\
- & & & \addedCC{\mbox{\textbf{Movable}}} & \addedCC{\mbox{$\rightarrow$}} \textbf{Output} \\
+ & & & \addedCC{\mbox{\textbf{Shuffle}}} & \addedCC{\mbox{$\rightarrow$}} \textbf{Output} \\
 \end{floattable}
 
 \pnum
@@ -1182,15 +1182,15 @@
 \textcolor{addclr}{\exitnote}
 \color{black}
 
-\rSec2[movable.iterators]{Movable iterators}
+\rSec2[shuffle.iterators]{Shuffle iterators}
 \pnum
 \addedCC{A class or built-in type \mbox{\tcode{X}} satisfies the
- requirements of a movable iterator if it meets the syntactic and
- semantic requirements of the \mbox{\tcode{MovableIterator}} concept.}
+ requirements of a shuffle iterator if it meets the syntactic and
+ semantic requirements of the \mbox{\tcode{ShuffleIterator}} concept.}
 
 \color{ccadd}
 \begin{codeblock}
-auto concept MovableIterator<typename X> {
+auto concept ShuffleIterator<typename X> {
   requires InputIterator<X>
         && NothrowDestructible<InputIterator<X>::value_type>
         && HasStdMove<InputIterator<X>::value_type>
@@ -1207,16 +1207,16 @@
 \color{black}
 
 \pnum
-\addedCC{A movable iterator is a form of input and output iterator
+\addedCC{A shuffle iterator is a form of input and output iterator
   that allows values to be moved into or out of a sequence, along with
- permitting efficient swapping of values within the sequence. Movable
+ permitting efficient swapping of values within the sequence. Shuffle
   iterators are typically used in algorithms that need to rearrange
   the elements within a sequence in a way that cannot be performed
   efficiently with swaps alone.}
 
 \pnum
 \addedCC{\enternote\ Any iterator that meets the additional requirements
- specified by \mbox{\tcode{MovableIterator}} is considered a movable
+ specified by \mbox{\tcode{ShuffleIterator}} is considered a shuffle
   iterator. \exitnote}
 
 \appendix


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