From 858e0e0c0b5b07786b6e15396a6fb196cbce0530 Mon Sep 17 00:00:00 2001 From: Jeremy Siek Date: Sun, 18 Jan 2004 20:26:02 +0000 Subject: [PATCH] new file [SVN r21817] --- doc/indirect_iterator_ref.diff | 245 +++++++++++++++++++++++++++++++++ 1 file changed, 245 insertions(+) create mode 100644 doc/indirect_iterator_ref.diff diff --git a/doc/indirect_iterator_ref.diff b/doc/indirect_iterator_ref.diff new file mode 100644 index 0000000..90749a4 --- /dev/null +++ b/doc/indirect_iterator_ref.diff @@ -0,0 +1,245 @@ +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``