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 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 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``