diff --git a/doc/facade-and-adaptor.diff b/doc/facade-and-adaptor.diff deleted file mode 100755 index 07f0e40..0000000 --- a/doc/facade-and-adaptor.diff +++ /dev/null @@ -1,228 +0,0 @@ -Index: facade-and-adaptor.rst -=================================================================== -RCS file: /cvsroot/boost/boost/libs/iterator/doc/facade-and-adaptor.rst,v -retrieving revision 1.9 -retrieving revision 1.14 -diff -b -d -u -r1.9 -r1.14 ---- facade-and-adaptor.rst 22 Sep 2003 19:55:00 -0000 1.9 -+++ facade-and-adaptor.rst 18 Jan 2004 15:51:06 -0000 1.14 -@@ -3,17 +3,25 @@ None - +++++++++++++++++++++++++++++ - - :Author: David Abrahams, Jeremy Siek, Thomas Witt --:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@acm.org -+:Contact: dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com - :organization: `Boost Consulting`_, Indiana University `Open Systems -- Lab`_, University of Hanover `Institute for Transport -- Railway Operation and Construction`_ --:date: $Date: 2004/01/18 19:56:39 $ --:Number: N1530=03-0113 -+ Lab`_, `Zephyr Associates, Inc.`_ -+:date: $Date: 2004/01/18 19:56:39 $ -+ -+:Number: This is a revised version of N1530_\ =03-0113, which was -+ accepted for Technical Report 1 by the C++ standard -+ committee's library working group. -+ -+.. Version 1.9 of this ReStructuredText document corresponds to -+ n1530_, the paper accepted by the LWG. -+ -+.. _n1530: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1530.html -+ - :copyright: Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All rights reserved - - .. _`Boost Consulting`: http://www.boost-consulting.com - .. _`Open Systems Lab`: http://www.osl.iu.edu --.. _`Institute for Transport Railway Operation and Construction`: http://www.ive.uni-hannover.de -+.. _`Zephyr Associates, Inc.`: http://www.styleadvisor.com - - :abstract: We propose a set of class templates that help programmers - build standard-conforming iterators, both from scratch and -@@ -124,15 +132,15 @@ None - ================= - - This proposal is formulated in terms of the new ``iterator concepts`` --as proposed in `n1477`_, since user-defined and especially adapted -+as proposed in n1550_, since user-defined and especially adapted - iterators suffer from the well known categorization problems that are - inherent to the current iterator categories. - --.. _`n1477`: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1477.html -+.. _n1550: http://anubis.dkuug.dk/JTC1/SC22/WG21/docs/papers/2003/n1550.html - --This proposal does not strictly depend on proposal `n1477`_, as there -+This proposal does not strictly depend on proposal n1550_, as there - is a direct mapping between new and old categories. This proposal --could be reformulated using this mapping if `n1477`_ was not accepted. -+could be reformulated using this mapping if n1550_ was not accepted. - - Interoperability - ================ -@@ -141,24 +149,24 @@ None - current standard. There are currently two defect reports that are - concerned with interoperability issues. - --Issue `179`_ concerns the fact that mutable container iterator types -+Issue 179_ concerns the fact that mutable container iterator types - are only required to be convertible to the corresponding constant - iterator types, but objects of these types are not required to - interoperate in comparison or subtraction expressions. This situation - is tedious in practice and out of line with the way built in types - work. This proposal implements the proposed resolution to issue --`179`_, as most standard library implementations do nowadays. In other -+179_, as most standard library implementations do nowadays. In other - words, if an iterator type A has an implicit or user defined - conversion to an iterator type B, the iterator types are interoperable - and the usual set of operators are available. - --Issue `280`_ concerns the current lack of interoperability between -+Issue 280_ concerns the current lack of interoperability between - reverse iterator types. The proposed new reverse_iterator template - fixes the issues raised in 280. It provides the desired - interoperability without introducing unwanted overloads. - --.. _`179`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179 --.. _`280`: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280 -+.. _179: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-defects.html#179 -+.. _280: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-active.html#280 - - - Iterator Facade -@@ -195,7 +203,7 @@ None - * ``filter_iterator``, which provides a view of an iterator range in - which some elements of the underlying range are skipped. - --.. _counting_iterator: -+.. _counting: - - * ``counting_iterator``, which adapts any incrementable type - (e.g. integers, iterators) so that incrementing/decrementing the -@@ -226,15 +234,13 @@ Issue 9.1 et al - :: - - struct use_default; -- const unsigned use_default_access = -1; - - struct iterator_core_access { /* implementation detail */ }; - - template < - class Derived - , class Value -- , unsigned AccessCategory -- , class TraversalCategory -+ , class CategoryOrTraversal - , class Reference = Value& - , class Difference = ptrdiff_t - > -@@ -244,8 +250,7 @@ Issue 9.1 et al. - class Derived - , class Base - , class Value = use_default -- , unsigned Access = use_default_access -- , class Traversal = use_default -+ , class CategoryOrTraversal = use_default - , class Reference = use_default - , class Difference = use_default - > -@@ -254,10 +259,9 @@ Issue 9.1 et al. - template < - class Iterator - , class Value = use_default -- , unsigned Access = use_default_access -- , class Traversal = use_default -+ , class CategoryOrTraversal = use_default - , class Reference = use_default - , class Difference = use_default - > - class indirect_iterator; - -Issue 9.44y - -+ template -+ struct pointee; -+ -+ template -+ struct indirect_reference; -+ - template - class reverse_iterator; - -@@ -277,8 +287,7 @@ Issue 9.1 et al. - - template < - class Incrementable -- , unsigned Access = use_default_access -- , class Traversal = use_default -+ , class CategoryOrTraversal = use_default - , class Difference = use_default - > - class counting_iterator -@@ -312,17 +321,35 @@ Issue 9.8 - Specialized adaptors [lib.iterator.special.adaptors] - ==================================================== - --.. The requirements for all of these need to be written *much* more -- formally -DWA -- - --[*Note:* The ``enable_if_convertible::type`` expression used in -+The ``enable_if_convertible::type`` expression used in - this section is for exposition purposes. The converting constructors - for specialized adaptors should be only be in an overload set provided - that an object of type ``X`` is implicitly convertible to an object of --type ``Y``. The ``enable_if_convertible`` approach uses SFINAE to -+type ``Y``. -+The signatures involving ``enable_if_convertible`` should behave -+*as-if* ``enable_if_convertible`` were defined to be:: -+ -+ template enable_if_convertible_impl -+ {}; -+ -+ template <> enable_if_convertible_impl -+ { struct type; }; -+ -+ template -+ struct enable_if_convertible -+ : enable_if_convertible_impl::value> -+ {}; -+ -+If an expression other than the default argument is used to supply -+the value of a function parameter whose type is written in terms -+of ``enable_if_convertible``, the program is ill-formed, no -+diagnostic required. -+ -+[*Note:* The ``enable_if_convertible`` approach uses SFINAE to - take the constructor out of the overload set when the types are not --implicitly convertible.] -+implicitly convertible. -+] - - - Indirect iterator -@@ -330,6 +357,16 @@ Issue 9.44y - - .. include:: indirect_iterator_abstract.rst - -+Class template ``pointee`` -+.................................... -+ -+.. include:: pointee_ref.rst -+ -+Class template ``indirect_reference`` -+..................................... -+ -+.. include:: indirect_reference_ref.rst -+ - Class template ``indirect_iterator`` - .................................... - -@@ -393,8 +430,7 @@ - - - --.. -- LocalWords: Abrahams Siek Witt istream ostream iter MTL strided interoperate -+.. LocalWords: Abrahams Siek Witt istream ostream iter MTL strided interoperate - LocalWords: CRTP metafunctions inlining lvalue JGS incrementable BGL LEDA cv - LocalWords: GraphBase struct ptrdiff UnaryFunction const int typename bool pp - LocalWords: lhs rhs SFINAE markup iff tmp OtherDerived OtherIterator DWA foo diff --git a/doc/indirect_iterator_ref.diff b/doc/indirect_iterator_ref.diff deleted file mode 100644 index 0c1bf5c..0000000 --- a/doc/indirect_iterator_ref.diff +++ /dev/null @@ -1,245 +0,0 @@ -Index: indirect_iterator_ref.rst -=================================================================== -RCS file: /cvsroot/boost/boost/libs/iterator/doc/indirect_iterator_ref.rst,v -retrieving revision 1.2 -retrieving revision 1.21 -diff -w -d -u -b -r1.2 -r1.21 ---- indirect_iterator_ref.rst 22 Sep 2003 19:55:00 -0000 1.2 -+++ indirect_iterator_ref.rst 15 Jan 2004 00:01:33 -0000 1.21 - - - -@@ -3,82 +3,139 @@ - template < - class Iterator - , class Value = use_default - -Issue 9.15 - -- , unsigned Access = use_default_access -- , class Traversal = use_default -+ , class CategoryOrTraversal = use_default - , class Reference = use_default - , class Difference = use_default - > - class indirect_iterator - -Issue 9.37x - -- : public iterator_adaptor - { -- friend class iterator_core_access; - public: -+ typedef /* see below */ value_type; -+ typedef /* see below */ reference; -+ typedef /* see below */ pointer; -+ typedef /* see below */ difference_type; -+ typedef /* see below */ iterator_category; -+ - indirect_iterator(); - indirect_iterator(Iterator x); -+ - -Issue 9.15 - - template < -- class Iterator2, class Value2, unsigned Access2, class Traversal2 -+ class Iterator2, class Value2, class Category2 - , class Reference2, class Difference2 - > - indirect_iterator( - indirect_iterator< -- Iterator2, Value2, Access2, Traversal2, Reference2, Difference2 -+ Iterator2, Value2, Category2, Reference2, Difference2 - > const& y - , typename enable_if_convertible::type* = 0 // exposition - ); - -Issue 9.37x - -- private: // as-if specification -- typename indirect_iterator::reference dereference() const -- { -- return **this->base(); -- } -+ -+ Iterator const& base() const; -+ reference operator*() const; -+ indirect_iterator& operator++(); -+ indirect_iterator& operator--(); -+ private: -+ Iterator m_iterator; // exposition - }; - -+ -+The member types of ``indirect_iterator`` are defined according to -+the following pseudo-code, where ``V`` is -+``iterator_traits::value_type`` -+ -+.. parsed-literal:: -+ -+ if (Value is use_default) then -+ typedef remove_const::type>::type value_type; -+ else -+ typedef remove_const::type value_type; -+ -+ if (Reference is use_default) then -+ if (Value is use_default) then -+ typedef indirect_reference::type reference; -+ else -+ typedef Value& reference; -+ else -+ typedef Reference reference; -+ -+ if (Value is use_default) then -+ typedef pointee::type\* pointer; -+ else -+ typedef Value\* pointer; -+ -+ if (Difference is use_default) -+ typedef iterator_traits::difference_type difference_type; -+ else -+ typedef Difference difference_type; -+ -+ if (CategoryOrTraversal is use_default) -+ typedef |iterator-category|_\ ( -+ iterator_traversal::type,``reference``,``value_type`` -+ ) iterator_category; -+ else -+ typedef |iterator-category|_\ ( -+ CategoryOrTraversal,``reference``,``value_type`` -+ ) iterator_category; -+ -+ - - ``indirect_iterator`` requirements - .................................. - -Issue 9.40x - --The ``value_type`` of the ``Iterator`` template parameter should --itself be dereferenceable. The return type of the ``operator*`` for --the ``value_type`` must be the same type as the ``Reference`` template --parameter. The ``Value`` template parameter will be the ``value_type`` --for the ``indirect_iterator``, unless ``Value`` is const. If ``Value`` --is ``const X``, then ``value_type`` will be *non-* ``const X``. The --default for ``Value`` is -+The expression ``*v``, where ``v`` is an object of -+``iterator_traits::value_type``, shall be valid -+expression and convertible to ``reference``. ``Iterator`` shall -+model the traversal concept indicated by ``iterator_category``. -+``Value``, ``Reference``, and ``Difference`` shall be chosen so -+that ``value_type``, ``reference``, and ``difference_type`` meet -+the requirements indicated by ``iterator_category``. - --:: -+[Note: there are further requirements on the -+``iterator_traits::value_type`` if the ``Value`` -+parameter is not ``use_default``, as implied by the algorithm for -+deducing the default for the ``value_type`` member.] - -- iterator_traits< iterator_traits::value_type >::value_type - -Issue 9.37x - -+``indirect_iterator`` models -+............................ - --If the default is used for ``Value``, then there must be a valid --specialization of ``iterator_traits`` for the value type of the base --iterator. -+In addition to the concepts indicated by ``iterator_category`` -+and by ``iterator_traversal::type``, a -+specialization of ``indirect_iterator`` models the following -+concepts, Where ``v`` is an object of -+``iterator_traits::value_type``: - --The ``Reference`` parameter will be the ``reference`` type of the --``indirect_iterator``. The default is ``Value&``. -+ * Readable Iterator if ``reference(*v)`` is convertible to -+ ``value_type``. - --The ``Access`` and ``Traversal`` parameters are passed unchanged to --the corresponding parameters of the ``iterator_adaptor`` base --class, and the ``Iterator`` parameter is passed unchanged as the --``Base`` parameter to the ``iterator_adaptor`` base class. -+ * Writable Iterator if ``reference(*v) = t`` is a valid -+ expression (where ``t`` is an object of type -+ ``indirect_iterator::value_type``) - --The indirect iterator will model the most refined standard traversal --concept that is modeled by the ``Iterator`` type. The indirect --iterator will model the most refined standard access concept that is --modeled by the value type of ``Iterator``. -+ * Lvalue Iterator if ``reference`` is a reference type. -+ -+``indirect_iterator`` is interoperable with -+``indirect_iterator`` if and only if ``X`` is -+interoperable with ``Y``. - - - ``indirect_iterator`` operations - ................................ - -Issue 9.37x - -+In addition to the operations required by the concepts described -+above, specializations of ``indirect_iterator`` provide the -+following operations. -+ -+ - -Issue 9.28 and 9.37x - - ``indirect_iterator();`` - - :Requires: ``Iterator`` must be Default Constructible. - :Returns: An instance of ``indirect_iterator`` with -- a default constructed base object. -+ a default-constructed ``m_iterator``. - - -Issue 9.37x - - ``indirect_iterator(Iterator x);`` - - :Returns: An instance of ``indirect_iterator`` with -- the ``iterator_adaptor`` subobject copy constructed from ``x``. -+ ``m_iterator`` copy constructed from ``x``. - - :: - - -Issue 9.29 - -@@ -94,5 +151,27 @@ - ); - - :Requires: ``Iterator2`` is implicitly convertible to ``Iterator``. --:Returns: An instance of ``indirect_iterator`` that is a copy of ``y``. -+:Returns: An instance of ``indirect_iterator`` whose -+ ``m_iterator`` subobject is constructed from ``y.base()``. -+ - -Issue 9.37x - -+``Iterator const& base() const;`` - -+:Returns: ``m_iterator`` -+ -+ -+``reference operator*() const;`` -+ -+:Returns: ``**m_iterator`` -+ -+ -+``indirect_iterator& operator++();`` -+ -+:Effects: ``++m_iterator`` -+:Returns: ``*this`` -+ -+ -+``indirect_iterator& operator--();`` -+ -+:Effects: ``--m_iterator`` -+:Returns: ``*this`` diff --git a/doc/iterator_adaptor_abstract.diff b/doc/iterator_adaptor_abstract.diff deleted file mode 100755 index 6cebd77..0000000 --- a/doc/iterator_adaptor_abstract.diff +++ /dev/null @@ -1,22 +0,0 @@ -Index: iterator_adaptor_abstract.rst -=================================================================== -RCS file: /cvsroot/boost/boost/libs/iterator/doc/iterator_adaptor_abstract.rst,v -retrieving revision 1.1 -retrieving revision 1.2 -diff -b -d -u -r1.1 -r1.2 ---- iterator_adaptor_abstract.rst 5 Aug 2003 18:19:55 -0000 1.1 -+++ iterator_adaptor_abstract.rst 24 Nov 2003 05:02:46 -0000 1.2 -@@ -1,5 +1,11 @@ Issue 9.21 --The ``iterator_adaptor`` is a base class template derived from an --instantiation of ``iterator_facade``. The core interface functions -+.. Version 1.1 of this ReStructuredText document corresponds to -+ n1530_, the paper accepted by the LWG. -+ -+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All -+ rights reserved -+ -+Each specialization of the ``iterator_adaptor`` class template is derived from -+a specialization of ``iterator_facade``. The core interface functions - expected by ``iterator_facade`` are implemented in terms of the - ``iterator_adaptor``\ 's ``Base`` template parameter. A class derived - from ``iterator_adaptor`` typically redefines some of the core diff --git a/doc/iterator_adaptor_body.diff b/doc/iterator_adaptor_body.diff deleted file mode 100755 index a170244..0000000 --- a/doc/iterator_adaptor_body.diff +++ /dev/null @@ -1,35 +0,0 @@ -Index: iterator_adaptor_body.rst -=================================================================== -RCS file: /cvsroot/boost/boost/libs/iterator/doc/iterator_adaptor_body.rst,v -retrieving revision 1.2 -retrieving revision 1.3 -diff -b -d -u -r1.2 -r1.3 ---- iterator_adaptor_body.rst 22 Sep 2003 19:55:00 -0000 1.2 -+++ iterator_adaptor_body.rst 24 Nov 2003 05:02:46 -0000 1.3 -@@ -1,3 +1,9 @@ -+.. Version 1.2 of this ReStructuredText document corresponds to -+ n1530_, the paper accepted by the LWG for TR1. -+ -+.. Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003. All -+ rights reserved -+ - The ``iterator_adaptor`` class template adapts some ``Base`` [#base]_ - type to create a new iterator. Instantiations of ``iterator_adaptor`` - are derived from a corresponding instantiation of ``iterator_facade`` -@@ -19,7 +25,7 @@ Issue 9.1 et al - redefined in the user's derived class. - - Several of the template parameters of ``iterator_adaptor`` default --to ``use_default`` (or ``use_default_access``). This allows the -+to ``use_default``. This allows the - user to make use of a default parameter even when she wants to - specify a parameter later in the parameter list. Also, the - defaults for the corresponding associated types are somewhat -@@ -28,6 +34,6 @@ Issue 9.45y - the identity of the ``use_default`` type is not left unspecified - because specification helps to highlight that the ``Reference`` - template parameter may not always be identical to the iterator's --``reference`` type, and will keep users making mistakes based on -+``reference`` type, and will keep users from making mistakes based on - that assumption. - diff --git a/doc/new-iter-concepts.pdf b/doc/new-iter-concepts.pdf index 636aaab..aa680ec 100755 Binary files a/doc/new-iter-concepts.pdf and b/doc/new-iter-concepts.pdf differ diff --git a/doc/transform_iterator_ref.diff b/doc/transform_iterator_ref.diff deleted file mode 100644 index 0f2d704..0000000 --- a/doc/transform_iterator_ref.diff +++ /dev/null @@ -1,202 +0,0 @@ -Index: transform_iterator_ref.rst -=================================================================== -RCS file: /cvsroot/boost/boost/libs/iterator/doc/transform_iterator_ref.rst,v -retrieving revision 1.3 -retrieving revision 1.15 -diff -w -d -u -b -r1.3 -r1.15 ---- transform_iterator_ref.rst 21 Sep 2003 11:13:46 -0000 1.3 -+++ transform_iterator_ref.rst 15 Jan 2004 00:06:57 -0000 1.15 -@@ -1,3 +1,5 @@ -+.. Version 1.3 of this document was accepted for TR1 -+ - :: - - template - class transform_iterator - -Issue 9.37x - -- : public iterator_adaptor - { -- friend class iterator_core_access; - public: -+ typedef /* see below */ value_type; -+ typedef /* see below */ reference; -+ typedef /* see below */ pointer; -+ typedef iterator_traits::difference_type difference_type; -+ typedef /* see below */ iterator_category; -+ - transform_iterator(); - transform_iterator(Iterator const& x, UnaryFunction f); - - -Issue 9.43x - -- template -+ template - transform_iterator( -- transform_iterator const& t -- , typename enable_if_convertible::type* = 0 // exposition -+ transform_iterator const& t -+ , typename enable_if_convertible::type* = 0 // exposition only -+ , typename enable_if_convertible::type* = 0 // exposition only - ); -- - -Issues 9.37x and 9.12 - -+ Iterator const& base() const; -+ reference operator*() const; -+ transform_iterator& operator++(); -+ transform_iterator& operator--(); - private: -- typename transform_iterator::value_type dereference() const; -- UnaryFunction m_f; -+ Iterator m_iterator; // exposition only -+ UnaryFunction m_f; // exposition only - }; - - -Issue 9.41x - -+If ``Reference`` is ``use_default`` then the ``reference`` member of -+``transform_iterator`` is -+``result_of::reference)>::type``. -+Otherwise, ``reference`` is ``Reference``. -+ -+If ``Value`` is ``use_default`` then the ``value_type`` member is -+``remove_cv >::type``. Otherwise, -+``value_type`` is ``Value``. -+ -+ - -Issue 9.37x - -+If ``Iterator`` models Readable Lvalue Iterator and if ``Iterator`` -+models Random Access Traversal Iterator, then ``iterator_category`` is -+convertible to ``random_access_iterator_tag``. Otherwise, if -+``Iterator`` models Bidirectional Traversal Iterator, then -+``iterator_category`` is convertible to -+``bidirectional_iterator_tag``. Otherwise ``iterator_category`` is -+convertible to ``forward_iterator_tag``. If ``Iterator`` does not -+model Readable Lvalue Iterator then ``iterator_category`` is -+convertible to ``input_iterator_tag``. -+ -+ - ``transform_iterator`` requirements - ................................... - -@@ -34,27 +65,55 @@ - where the type of ``f(*i)`` must be - ``result_of::reference)>::type``. - - -Issue 9.37x - --The type ``Iterator`` must at least model Readable Iterator. The --resulting ``transform_iterator`` models the most refined of the -+The argument ``Iterator`` shall model Readable Iterator. -+ -+ -+``transform_iterator`` models -+............................. -+ -+The resulting ``transform_iterator`` models the most refined of the - following options that is also modeled by ``Iterator``. - -- * Writable Lvalue Iterator if ``result_of::reference)>::type`` is a non-const reference. -+ * Writable Lvalue Iterator if ``transform_iterator::reference`` is a non-const reference. - -- * Readable Lvalue Iterator if ``result_of::reference)>::type`` is a const -- reference. -+ * Readable Lvalue Iterator if ``transform_iterator::reference`` is a const reference. - - * Readable Iterator otherwise. - -- - The ``transform_iterator`` models the most refined standard traversal --concept that is modeled by ``Iterator``. -+concept that is modeled by the ``Iterator`` argument. - -Issue 9.41x - --The ``reference`` type of ``transform_iterator`` is --``result_of::reference)>::type``. --The ``value_type`` is ``remove_cv >::type``. - -Issue 9.37x. - -+If ``transform_iterator`` is a model of Readable Lvalue Iterator then -+it models the following original iterator concepts depending on what -+the ``Iterator`` argument models. - --``transform_iterator`` public operations --........................................ -++-----------------------------------+---------------------------------+ -+| If ``Iterator`` models | then ``filter_iterator`` models | -++===================================+=================================+ -+| Single Pass Iterator | Input Iterator | -++-----------------------------------+---------------------------------+ -+| Forward Traversal Iterator | Forward Iterator | -++-----------------------------------+---------------------------------+ -+| Bidirectional Traversal Iterator | Bidirectional Iterator | -++-----------------------------------+---------------------------------+ -+| Random Access Traversal Iterator | Random Access Iterator | -++-----------------------------------+---------------------------------+ -+ -+If ``transform_iterator`` models Writable Lvalue Iterator then it is a -+mutable iterator (as defined in the old iterator requirements). -+ -+``transform_iterator`` is interoperable with -+``transform_iterator`` if and only if ``X`` is -+interoperable with ``Y``. -+ -+ -+ -+``transform_iterator`` operations -+................................. -+ -+In addition to the operations required by the concepts modeled by -+``transform_iterator``, ``transform_iterator`` provides the following -+operations. - - - ``transform_iterator();`` -@@ -80,14 +139,30 @@ - :Returns: An instance of ``transform_iterator`` that is a copy of ``t``. - :Requires: ``OtherIterator`` is implicitly convertible to ``Iterator``. - -+ -+``Iterator const& base() const;`` -+ -+:Returns: ``m_iterator`` -+ -+ - ``UnaryFunction functor() const;`` - - :Returns: ``m_f`` - --``transform_iterator`` private operations --......................................... - --``typename transform_iterator::value_type dereference() const;`` -+``reference operator*() const;`` - --:Returns: ``m_f(transform_iterator::dereference());`` -+:Returns: ``m_f(*m_iterator)`` -+ -+ -+``transform_iterator& operator++();`` -+ -+:Effects: ``++m_iterator`` -+:Returns: ``*this`` -+ -+ -+``transform_iterator& operator--();`` -+ -+:Effects: ``--m_iterator`` -+:Returns: ``*this`` -